예제 #1
0
void jrst_filter_init (void)
{
  char *filename = getenv ("JRST_FILTER");
  if (!filename) {
    return;
  }

  FILE *file = fopen (filename, "r");
  if (!file){
    return;
  }

  hcreate_r (1000, &classes);
  hcreate_r (1000, &methods);
  hash_initialized = 1;

  char p1[JRST_MAX_STRING];
  ParseState state = ParseStart;
  while (!feof(file)){
    fscanf (file, "%s", p1);
    switch (state){
    case ParseStart:
      switch (p1[0]){
      case 'C': state = ParseClass; break;
      case 'M': state = ParseMethod; break;
      }
      break;
    case ParseClass:
      {
        ENTRY e, *ep = NULL;
        e.key = p1;
        e.data = NULL;
        hsearch_r (e, FIND, &ep, &classes);
        if (ep == NULL){
          e.key = strdup (p1);
          e.data = NULL;
          hsearch_r (e, ENTER, &ep, &classes);
        }
      }
      state = ParseStart;
      break;
    case ParseMethod:
      {
        ENTRY e, *ep = NULL;
        e.key = p1;
        e.data = NULL;
        hsearch_r (e, FIND, &ep, &methods);
        if (ep == NULL){
          e.key = strdup (p1);
          e.data = NULL;
          hsearch_r (e, ENTER, &ep, &methods);
        }
      }
      state = ParseStart;
      break;
    }     
  }
  fclose(file);
}
예제 #2
0
void
init_cgi(char *query)
{
	int len, nel;
	char *q, *name, *value;

	/* Clear variables */
	if (!query) {
		hdestroy_r(&htab);
		return;
	}

	/* Parse into individual assignments */
	q = query;
	len = strlen(query);
	nel = 1;
	while (strsep(&q, "&;"))
		nel++;
	hcreate_r(nel, &htab);

	for (q = query; q < (query + len);) {
		/* Unescape each assignment */
		unescape(name = value = q);

		/* Skip to next assignment */
		for (q += strlen(q); q < (query + len) && !*q; q++);

		/* Assign variable */
		name = strsep(&value, "=");
		if (value) {
//			printf("set_cgi: name=%s, value=%s.\n", name , value);	// N12 test
			set_cgi(name, value);
		}
	}
}
예제 #3
0
파일: modules.c 프로젝트: jberaud/lttng2lxt
void modules_init(void)
{
	unsigned int modcnt;
	int i, status;
	ENTRY entry, *ret;

	status = hcreate_r(100, &table);
	assert(status);

    modcnt = &__modules_end-&__modules_begin-1;
	INFO("modules (%d):", modcnt);

	for (i = 0; i < modcnt; i++) {
		entry.key = mk_module_key(modtab[i].channel, modtab[i].name);
		entry.data = &modtab[i];
		status = hsearch_r(entry, ENTER, &ret, &table);
        assert(status);
		if (verbose) {
			fprintf(stderr, " %s.%s", modtab[i].channel, modtab[i].name);
		}
	}
	if (verbose) {
		fprintf(stderr,"\n");
	}
}
예제 #4
0
void webcgi_init(char *query)
{
       int nel;
       char *q, *end, *name, *value;
 
       if (htab.table) hdestroy_r(&htab);
       if (query == NULL) return;
 
//    cprintf("query = %s\n", query);
       
       end = query + strlen(query);
       q = query;
       nel = 1;
       while (strsep(&q, "&;")) {
               nel++;
       }
       hcreate_r(nel, &htab);
 
       for (q = query; q < end; ) {
               value = q;
               q += strlen(q) + 1;
 
               unescape(value);
               name = strsep(&value, "=");
               if (value) webcgi_set(name, value);
       }
}
예제 #5
0
int mod_static_init() {
    int i;
    int j;
    size_t size;
    ENTRY item, *ret;
    char **ext = NULL;

    size = sizeof(standard_types) / sizeof(standard_types[0]);

    bzero(&std_mime_type_hash, sizeof(struct hsearch_data));
    if (hcreate_r(size * 2, &std_mime_type_hash) == 0) {
        error("Error creating standard MIME type hash");
        return -1;
    }
    for (i = 0; i < size; i++) {
        for (ext = standard_types[i].exts, j = 0;
             *ext != NULL && j < FILE_TYPE_COUNT;
             ext++, j++) {
            item.key = *ext;
            item.data = standard_types[i].content_type;
            debug("Registering standard MIME type %s:%s",
                  *ext, standard_types[i].content_type);
            if (hsearch_r(item, ENTER, &ret, &std_mime_type_hash) == 0) {
                error("Error entering standard MIME type");
            }
        }
    }
    return 0;
}
예제 #6
0
/*
 * Allocate a hash table for fs handles. Returns 0 on success,
 * -1 on failure.
 */
int allocFsTable(void) {
  assert(NULL == fsTable);
  fsTable = calloc(1, sizeof(struct hsearch_data));
  if (0 == hcreate_r(MAX_ELEMENTS, fsTable)) {
    ERROR("Unable to initialize connection table");
    return -1;
  }
  return 0;
}
예제 #7
0
파일: aide.c 프로젝트: openpts/openpts
/**
 * new AIDE_CONTEXT
 */
AIDE_CONTEXT * newAideContext() {
    int rc;
    AIDE_CONTEXT *ctx;

    ctx = xmalloc(sizeof(AIDE_CONTEXT));
    if (ctx == NULL) {
        LOG(LOG_ERR, "no memory");
        return NULL;
    }
    memset(ctx, 0, sizeof(AIDE_CONTEXT));

    /* hash tables */
    // TODO set the size in openpts.h
    ctx->aide_md_table = xmalloc(sizeof(struct hsearch_data));
    // TODO ck null
    memset(ctx->aide_md_table, 0, sizeof(struct hsearch_data));
    rc = hcreate_r(AIDE_HASH_TABLE_SIZE, ctx->aide_md_table);  // hash table for metadata
    if (rc == 0) {
        LOG(LOG_ERR, "hcreate faild, errno=%x\n", errno);
        goto error;
    }
    ctx->aide_md_table_size = 0;

    ctx->aide_in_table = xmalloc(sizeof(struct hsearch_data));
    if (ctx->aide_in_table == NULL) {
        LOG(LOG_ERR, "no memory");
        goto error;
    }
    memset(ctx->aide_in_table, 0, sizeof(struct hsearch_data));
    //  4096 full
    rc = hcreate_r(AIDE_HASH_TABLE_SIZE, ctx->aide_in_table);  // hash table for ignore name
    if (rc == 0) {
        LOG(LOG_ERR, "hcreate faild\n");
        goto error;
    }
    ctx->aide_in_table_size = 0;

    DEBUG("newAideContext %p\n", ctx);
    return ctx;

  error:
    if (ctx != NULL) xfree(ctx);
    return NULL;
}
예제 #8
0
파일: graph.c 프로젝트: nikmikov/misc
Graph*		
graph_new 		(size_t max_nodes)
{
     Graph *graph = malloc (sizeof(Graph));
     graph->num_nodes = 0;
     graph->nodes = NULL;
     graph->nodes_arr_size = 0;
     hcreate_r (max_nodes, &graph->htab);
     return graph;
}
예제 #9
0
struct hsearch_data *
hash_create(ssize_t len) {
    struct hsearch_data * table;
    table = malloc(sizeof(table));
    check_mem(table);
    check(hcreate_r(len, table), "hash_create: fail to create an htable -> return NULL");
    return table;
    error:
    if (table) free(table);
    return NULL;
}
예제 #10
0
파일: ibc.c 프로젝트: vitovitolo/test
int main(int argc, char *argv[]) {
    int err, i;
    struct ibc_opts ibc_opts;
    struct inotify_event *evt;
    char buf[BUF_LEN], output[FILEPATH_BUF_SZ];
    const char *fp;

    memset(&ibc, 0, sizeof(struct ibc));
    err = hcreate_r(HTAB_SIZE, &ibc.htab);
    if (err == 0) {
        perror("hcreate_r");
        goto hcreate_error;
    }

    err = parse_opts(&ibc_opts, argc, argv);
    if (err == -1) {
        goto parsing_error;
    }

    for (i = 0; i < argc; i++)
        memset(argv[i], 0, strlen(argv[i]));


    err = ibc.fd = inotify_init();
    if (err == -1) {
        perror("inotify_init");
        goto inotify_init_error;
    }

    err = add_watches(&ibc_opts);
    if (err == -1) {
        goto add_watches_error;
    }

    while(read(ibc.fd, buf, BUF_LEN) > 0) {
        evt = (struct inotify_event *) buf;
        fp = get_inotify_event_path(evt->wd, evt->name);
        if (fp) {
            snprintf(output, FILEPATH_BUF_SZ, "%s/%s", ibc_opts.output_dir,
                    evt->name);
            cp(output, fp);
        }
    }

add_watches_error:
    close(ibc.fd);
inotify_init_error:
    free_opts(&ibc_opts);
parsing_error:
hcreate_error:
    hdestroy_r(&ibc.htab);
    return err;
}
예제 #11
0
int cln_init()
{
    int ret;
    assert(ctx_count==0);
    ret = hcreate_r(RFS_MAX_CLIENT_CONNECTION, &ctx_hosts);
    if(ret!=0) {
        fprintf(stderr, "<%s> failed hcreate_r() to create connection table! "
                "ERROR: %s\n", __func__, strerror(errno));
        abort();
    }
    return 0;
}
예제 #12
0
static void
stat_add(char *name, TSMgmtInt amount, TSStatPersistence persist_type, TSMutex create_mutex)
{
int stat_id = -1;
ENTRY search, *result = NULL;
static __thread struct hsearch_data stat_cache;
static __thread bool hash_init = false;

if (unlikely(!hash_init)) {
    hcreate_r(TS_MAX_API_STATS << 1, &stat_cache);
    hash_init = true;
    TSDebug(DEBUG_TAG, "stat cache hash init");
}

search.key  = name;
search.data = 0;
hsearch_r(search, FIND, &result, &stat_cache);

if (unlikely(result == NULL)) {
    // This is an unlikely path because we most likely have the stat cached
    // so this mutex won't be much overhead and it fixes a race condition
    // in the RecCore. Hopefully this can be removed in the future.
    TSMutexLock(create_mutex);
    if (TS_ERROR == TSStatFindName((const char *)name, &stat_id)) {
        stat_id = TSStatCreate((const char *)name, TS_RECORDDATATYPE_INT, persist_type, TS_STAT_SYNC_SUM);
        if (stat_id == TS_ERROR) {
            TSDebug(DEBUG_TAG, "Error creating stat_name: %s", name);
        } else {
            TSDebug(DEBUG_TAG, "Created stat_name: %s stat_id: %d", name, stat_id);
        }
    }
    TSMutexUnlock(create_mutex);

    if (stat_id >= 0) {
        search.key  = TSstrdup(name);
        search.data = (void *)((intptr_t)stat_id);
        hsearch_r(search, ENTER, &result, &stat_cache);
        TSDebug(DEBUG_TAG, "Cached stat_name: %s stat_id: %d", name, stat_id);
    }
} else {
    stat_id = (int)((intptr_t)result->data);
}

if (likely(stat_id >= 0)) {
    TSStatIntIncrement(stat_id, amount);
} else {
    TSDebug(DEBUG_TAG, "stat error! stat_name: %s stat_id: %d", name, stat_id);
}
}
예제 #13
0
ENTRY *
hsearch(ENTRY item, ACTION action)
{
    ENTRY *retval;

    /* Create global hash table if needed. */
    if (!global_hashtable_initialized) {
        if (hcreate_r(0, &global_hashtable) == 0)
            return (NULL);
        global_hashtable_initialized = true;
    }
    if (hsearch_r(item, action, &retval, &global_hashtable) == 0)
        return (NULL);
    return (retval);
}
예제 #14
0
파일: hash.c 프로젝트: clflush/tty64
hashtable *hashtable_create(int entries) {

	hashtable *tmp = NULL;

	tmp = calloc(1, sizeof(hashtable));

	if (!tmp) {
		lerror("calloc");
		return NULL;
	}

	if (hcreate_r(entries, tmp) < 1) {
		return NULL;
	}

	return tmp;
}
예제 #15
0
void webcgi_set(char *name, char *value)
{
       ENTRY e, *ep;
 
       if (!htab.table) {
               hcreate_r(16, &htab);
       }
 
       e.key = name;
       hsearch_r(e, FIND, &ep, &htab);
       if (ep) {
               ep->data = value;
       }
       else {
               e.data = value;
               hsearch_r(e, ENTER, &ep, &htab);
       }
}
예제 #16
0
int ewf_hashtable_create( ewf_hashtable_t ** htab, size_t size )
{
    /* From the man page:
     * "The struct it points to must be zeroed before the first call to hcreate_r()."
     */
    *htab = calloc( 1, sizeof( struct hsearch_data ) );

    if ( *htab == NULL ) {
	nbu_log_error( "hash table allocation failed" );
	return EWF_ERROR;
    }

    if ( hcreate_r( size, *htab ) == 0 ) {
	nbu_log_error( "hash table creation failed" );
	return EWF_ERROR;
    }

    return EWF_SUCCESS;
}
예제 #17
0
void* hook_add(const char *func_name, void *func_ptr)
{
    #define MAX_HTAB_ENTRIES 400
    if (htab == NULL) {
        htab = calloc(1, sizeof(struct hsearch_data));
        hcreate_r(MAX_HTAB_ENTRIES, htab);
    }

    ENTRY e, *ep=NULL;
    e.key = strdup(func_name);
    e.data = func_ptr;
    int rv = hsearch_r(e, ENTER, &ep, htab);
    if (ep == NULL) {
        fprintf(stderr, "entry failed:%s %s\n",func_name, strerror(errno));
        return NULL;
    }

    LOGD("HOOKED:%s",func_name);
    return ep->data;
}
예제 #18
0
void init_cgi(char *query)
{
	int len, nel;
	char *q, *name, *value;

	htab_count = 0;

	//cprintf("\nIn init_cgi(), query = %s\n", query);

	/* Clear variables */
	if (!query) {
		hdestroy_r(&htab);
		return;
	}

	/* Parse into individual assignments */
	q = query;
	len = strlen(query);
	nel = 1;
	while (strsep(&q, "&;"))
		nel++;
	hcreate_r(nel, &htab);
	//cprintf("\nIn init_cgi(), nel = %d\n", nel);

	for (q = query; q < (query + len);) {
		/* Unescape each assignment */
		unescape(name = value = q);

		/* Skip to next assignment */
		for (q += strlen(q); q < (query + len) && !*q; q++) ;

		/* Assign variable */
		name = strsep(&value, "=");
		if (value)
			set_cgi(name, value);
	}
	//cprintf("\nIn init_cgi(), AFTER PROCESS query = %s\n", query);
}
예제 #19
0
/*****************************************************************************
 函 数 名  : subdesc_create_hashtable
 功能描述  : 根据doc中包括的有name的元素的数量创建hash表
 输入参数  : doc sub文档 root 结构指针
 输出参数  : 无
 返 回 值  : ERR_SUCCESS成功 其他失败
 调用函数  :
 被调函数  :
 ============================================================================
 修改历史      :
  1.日    期   : 2008年8月26日
    
    修改内容   : 新生成函数

*****************************************************************************/
static int subdesc_create_hashtable(xmlDocPtr doc, SUB_ROOT * root)
{
    xmlXPathContextPtr xpathCtx;
    int ret = ERROR_SUCCESS;

    /* Create xpath evaluation context */
    xpathCtx = xmlXPathNewContext(doc);
    if(xpathCtx == NULL)
    {
        return ERROR_SYSTEM;
    }

    xmlXPathObjectPtr xpathObj;

    /* Evaluate xpath expression */
    xpathObj = xmlXPathEvalExpression((unsigned char*)"//*[@name]", xpathCtx);
    if(xpathObj != NULL)
    {
        if(NULL == xpathObj->nodesetval ||
           xpathObj->nodesetval->nodeNr ==0 ||
           0 == hcreate_r(xpathObj->nodesetval->nodeNr,
                   (struct hsearch_data *)(root->_hashtable)))
        {
            ret = ERROR_SYSTEM;
        }
        xmlXPathFreeObject(xpathObj);
    }
    else
    {
        ret = ERROR_SYSTEM;
    }

    xmlXPathFreeContext(xpathCtx);

    return ret;

}
예제 #20
0
int himport_r(struct hsearch_data *htab,
		const char *env, size_t size, const char sep, int flag,
		int crlf_is_lf, int nvars, char * const vars[])
{
	char *data, *sp, *dp, *name, *value;
	char *localvars[nvars];
	int i;

	/* Test for correct arguments.  */
	if (htab == NULL) {
		__set_errno(EINVAL);
		return 0;
	}

	/* we allocate new space to make sure we can write to the array */
	if ((data = malloc(size + 1)) == NULL) {
		debug("himport_r: can't malloc %lu bytes\n", (ulong)size + 1);
		__set_errno(ENOMEM);
		return 0;
	}
	memcpy(data, env, size);
	data[size] = '\0';
	dp = data;

	/* make a local copy of the list of variables */
	if (nvars)
		memcpy(localvars, vars, sizeof(vars[0]) * nvars);

	if ((flag & H_NOCLEAR) == 0) {
		/* Destroy old hash table if one exists */
		debug("Destroy Hash Table: %p table = %p\n", htab,
		       htab->table);
		if (htab->table)
			hdestroy_r(htab);
	}

	/*
	 * Create new hash table (if needed).  The computation of the hash
	 * table size is based on heuristics: in a sample of some 70+
	 * existing systems we found an average size of 39+ bytes per entry
	 * in the environment (for the whole key=value pair). Assuming a
	 * size of 8 per entry (= safety factor of ~5) should provide enough
	 * safety margin for any existing environment definitions and still
	 * allow for more than enough dynamic additions. Note that the
	 * "size" argument is supposed to give the maximum environment size
	 * (CONFIG_ENV_SIZE).  This heuristics will result in
	 * unreasonably large numbers (and thus memory footprint) for
	 * big flash environments (>8,000 entries for 64 KB
	 * environment size), so we clip it to a reasonable value.
	 * On the other hand we need to add some more entries for free
	 * space when importing very small buffers. Both boundaries can
	 * be overwritten in the board config file if needed.
	 */

	if (!htab->table) {
		int nent = CONFIG_ENV_MIN_ENTRIES + size / 8;

		if (nent > CONFIG_ENV_MAX_ENTRIES)
			nent = CONFIG_ENV_MAX_ENTRIES;

		debug("Create Hash Table: N=%d\n", nent);

		if (hcreate_r(nent, htab) == 0) {
			free(data);
			return 0;
		}
	}

	if (!size) {
		free(data);
		return 1;		/* everything OK */
	}
	if(crlf_is_lf) {
		/* Remove Carriage Returns in front of Line Feeds */
		unsigned ignored_crs = 0;
		for(;dp < data + size && *dp; ++dp) {
			if(*dp == '\r' &&
			   dp < data + size - 1 && *(dp+1) == '\n')
				++ignored_crs;
			else
				*(dp-ignored_crs) = *dp;
		}
		size -= ignored_crs;
		dp = data;
	}
	/* Parse environment; allow for '\0' and 'sep' as separators */
	do {
		ENTRY e, *rv;

		/* skip leading white space */
		while (isblank(*dp))
			++dp;

		/* skip comment lines */
		if (*dp == '#') {
			while (*dp && (*dp != sep))
				++dp;
			++dp;
			continue;
		}

		/* parse name */
		for (name = dp; *dp != '=' && *dp && *dp != sep; ++dp)
			;

		/* deal with "name" and "name=" entries (delete var) */
		if (*dp == '\0' || *(dp + 1) == '\0' ||
		    *dp == sep || *(dp + 1) == sep) {
			if (*dp == '=')
				*dp++ = '\0';
			*dp++ = '\0';	/* terminate name */

			debug("DELETE CANDIDATE: \"%s\"\n", name);
			if (!drop_var_from_set(name, nvars, localvars))
				continue;

			if (hdelete_r(name, htab, flag) == 0)
				debug("DELETE ERROR ##############################\n");

			continue;
		}
		*dp++ = '\0';	/* terminate name */

		/* parse value; deal with escapes */
		for (value = sp = dp; *dp && (*dp != sep); ++dp) {
			if ((*dp == '\\') && *(dp + 1))
				++dp;
			*sp++ = *dp;
		}
		*sp++ = '\0';	/* terminate value */
		++dp;

		if (*name == 0) {
			debug("INSERT: unable to use an empty key\n");
			__set_errno(EINVAL);
			free(data);
			return 0;
		}

		/* Skip variables which are not supposed to be processed */
		if (!drop_var_from_set(name, nvars, localvars))
			continue;

		/* enter into hash table */
		e.key = name;
		e.data = value;

		hsearch_r(e, ENTER, &rv, htab, flag);
		if (rv == NULL)
			printf("himport_r: can't insert \"%s=%s\" into hash table\n",
				name, value);

		debug("INSERT: table %p, filled %d/%d rv %p ==> name=\"%s\" value=\"%s\"\n",
			htab, htab->filled, htab->size,
			rv, name, value);
	} while ((dp < data + size) && *dp);	/* size check needed for text */
						/* without '\0' termination */
	debug("INSERT: free(data = %p)\n", data);
	free(data);

	/* process variables which were not considered */
	for (i = 0; i < nvars; i++) {
		if (localvars[i] == NULL)
			continue;
		/*
		 * All variables which were not deleted from the variable list
		 * were not present in the imported env
		 * This could mean two things:
		 * a) if the variable was present in current env, we delete it
		 * b) if the variable was not present in current env, we notify
		 *    it might be a typo
		 */
		if (hdelete_r(localvars[i], htab, flag) == 0)
			printf("WARNING: '%s' neither in running nor in imported env!\n", localvars[i]);
		else
			printf("WARNING: '%s' not in imported env, deleting it!\n", localvars[i]);
	}

	debug("INSERT: done\n");
	return 1;		/* everything OK */
}
예제 #21
0
파일: args.c 프로젝트: jkkm/latrace
int lt_args_add_enum(struct lt_config_shared *cfg, char *name, 
			struct lt_list_head *h)
{
	ENTRY e, *ep;
	struct lt_enum_elem *elem, *last = NULL;
	struct lt_enum *en;
	int i = 0;

	if (NULL == (en = malloc(sizeof(*en))))
		return -1;

	memset(en, 0x0, sizeof(*en));
	en->name = name;

	/* Initialize the hash table holding enum names */
	if (!enum_init) {
	        if (!hcreate_r(LT_ARGS_DEF_ENUM_NUM, &args_enum_tab)) {
	                perror("failed to create has table:");
			free(en);
	                return -1;
	        }
		enum_init = 1;
	}

	e.key = en->name;
	e.data = en;

	if (!hsearch_r(e, ENTER, &ep, &args_enum_tab)) {
		perror("hsearch_r failed");
		free(en);
		return 1;
	}

	/* We've got enum inside the hash, let's prepare the enum itself.
	   The 'elems' field is going to be the qsorted list of 
	   'struct enum_elem's */
	lt_list_for_each_entry(elem, h, list)
		en->cnt++;

	if (NULL == (en->elems = malloc(sizeof(struct lt_enum_elem) * en->cnt)))
		return -1;

	PRINT_VERBOSE(cfg, 3, "enum %s (%d elems) not fixed\n",
			en->name, en->cnt);

	/*
	 * The enum element can be:
	 *
	 * 1) defined
	 * 2) undefined
	 * 3) defined via string reference
	 *
	 * ad 1) no work
	 * ad 2) value of previous element is used
	 * ad 3) we look for the string reference in defined elements' names
	 *
	 * This being said, following actions will happen now:
	 *
	 * - copy all the values to the prepared array
	 * - fix the values based on the above
	 * - sort the array
	 */

	lt_list_for_each_entry(elem, h, list) {

		PRINT_VERBOSE(cfg, 3, "\t %s = %d/%s\n",
			elem->name, elem->val, elem->strval);

		en->elems[i++] = *elem;
	}
예제 #22
0
// read symbol table from elf_file
struct symtab *build_symtab(const char *elf_file) {
  int fd;
  Elf *elf;
  Elf32_Ehdr *ehdr;
  char *names;
  struct symtab *symtab = NULL;

  if ((fd = open(elf_file, O_RDONLY)) < 0) {
    perror("open");
    return NULL;
  }

  elf = elf_begin(fd, ELF_C_READ, NULL);
  if (elf == NULL || elf_kind(elf) != ELF_K_ELF) {
    // not an elf
    close(fd);
    return NULL;
  }

  // read ELF header
  if ((ehdr = elf32_getehdr(elf)) != NULL) {
    Elf_Scn *scn;
    struct elf_section *scn_cache, *scn_cache_ptr;
    int cnt;

    // read section headers into scn_cache
    scn_cache = (struct elf_section *)
                malloc(ehdr->e_shnum * sizeof(struct elf_section));
    scn_cache_ptr = scn_cache;
    scn_cache_ptr++;

    for (scn = NULL; scn = elf_nextscn(elf, scn); scn_cache_ptr++) {
      scn_cache_ptr->c_shdr = elf32_getshdr(scn);
      scn_cache_ptr->c_data = elf_getdata(scn, NULL);
    }

    for (cnt = 1; cnt < ehdr->e_shnum; cnt++) {
      Elf32_Shdr *shdr = scn_cache[cnt].c_shdr;

      if (shdr->sh_type == SHT_SYMTAB) {
        Elf32_Sym  *syms;
        int j, n, rslt;
        size_t size;

        // FIXME: there could be multiple data buffers associated with the
        // same ELF section. Here we can handle only one buffer. See man page
        // for elf_getdata on Solaris.

        guarantee(symtab == NULL, "multiple symtab");
        symtab = (struct symtab *)calloc(1, sizeof(struct symtab));

        // the symbol table
        syms = (Elf32_Sym *)scn_cache[cnt].c_data->d_buf;

        // number of symbols
        n = shdr->sh_size / shdr->sh_entsize;

        // create hash table, we use hcreate_r, hsearch_r and hdestroy_r to
        // manipulate the hash table.
        symtab->hash_table = calloc(1, sizeof(struct hsearch_data));
        rslt = hcreate_r(n, symtab->hash_table);
        guarantee(rslt, "unexpected failure: hcreate_r");

        // shdr->sh_link points to the section that contains the actual strings
        // for symbol names. the st_name field in Elf32_Sym is just the
        // string table index. we make a copy of the string table so the
        // strings will not be destroyed by elf_end.
        size = scn_cache[shdr->sh_link].c_data->d_size;
        symtab->strs = (char *)malloc(size);
        memcpy(symtab->strs, scn_cache[shdr->sh_link].c_data->d_buf, size);

        // allocate memory for storing symbol offset and size;
        symtab->symbols = (struct elf_symbol *)malloc(n * sizeof(struct elf_symbol));

        // copy symbols info our symtab and enter them info the hash table
        for (j = 0; j < n; j++, syms++) {
          ENTRY item, *ret;
          char *sym_name = symtab->strs + syms->st_name;

          symtab->symbols[j].name   = sym_name;
          symtab->symbols[j].offset = syms->st_value;
          symtab->symbols[j].size   = syms->st_size;

          // skip empty strings
          if (*sym_name == '\0') continue;

          item.key = sym_name;
          item.data = (void *)&(symtab->symbols[j]);

          hsearch_r(item, ENTER, &ret, symtab->hash_table);
        }
      }
    }

    free(scn_cache);
  }

  elf_end(elf);
  close(fd);

  return symtab;
}
예제 #23
0
int hcreate (size_t nel) { return hcreate_r(nel, the_global_hsearch_data); }
예제 #24
0
int
main (int argc, char *argv[])
{
    char line[1000000];
    FILE *in, *out;
    int line_length;
    int total_num_root_entities;
    int total_num_sub_entities;
    long num_entities;
    unsigned long *temp;
    int index;
    int ret;
    int fd_entities_path, fd_hash_path;
    int result;
    int roots, subs;
    int num_lines = 0;
    int num_dups = 0;
    int json = 1;
    struct entity *entities = 0;
    struct hsearch_data htab;

    if (hcreate_r (LARGE_HASH_TABLE, &htab) == 0)
    {
        perror ("Could not create hash table");
        exit (2);
    }

// Begin MMAP stuff:
//
// Open an mmap file for writing.
// - Creating the file if it doesn't exist.
// - Truncating it to 0 size if it already exists. (not really needed)
// Note: "O_WRONLY" mode is not sufficient when mmaping.
//
    fd_entities_path =
        open (ENTITIES_FILEPATH, O_RDWR | O_CREAT | O_TRUNC, (mode_t) 0600);
    if (fd_entities_path == -1)
    {
        perror ("Error opening mmap file for writing");
        exit (EXIT_FAILURE);
    }
    fd_hash_path =
        open (HASH_FILEPATH, O_RDWR | O_CREAT | O_TRUNC, (mode_t) 0600);
    if (fd_hash_path == -1)
    {
        perror ("Error opening mmap file for writing");
        exit (EXIT_FAILURE);
    }

// Stretch the file size to the size of the (mmapped) array of ints
//
    result = lseek (fd_entities_path, ENTITIES_FILESIZE - 1, SEEK_SET);
    if (result == -1)
    {
        close (fd_entities_path);
        perror ("Error calling lseek() to 'stretch' the file");
        exit (EXIT_FAILURE);
    }
    result = lseek (fd_hash_path, HASH_FILESIZE - 1, SEEK_SET);
    if (result == -1)
    {
        close (fd_hash_path);
        perror ("Error calling lseek() to 'stretch' the file");
        exit (EXIT_FAILURE);
    }

// Something needs to be written at the end of the file to
// have the file actually have the new size.
// Just writing an empty string at the current file position will do.
// 
// Note:
//  - The current position in the file is at the end of the stretched
//    file due to the call to lseek().
//  - An empty string is actually a single '\0' character, so a zero-byte
//    will be written at the last byte of the file.
//    
    result = write (fd_entities_path, "", 1);
    if (result != 1)
    {
        close (fd_entities_path);
        perror ("Error writing last byte of the file");
        exit (EXIT_FAILURE);
    }
    result = write (fd_hash_path, "", 1);
    if (result != 1)
    {
        close (fd_hash_path);
        perror ("Error writing last byte of the file");
        exit (EXIT_FAILURE);
    }

// Now the file is ready to be mmapped.
//
    entities =
        mmap (0, ENTITIES_FILESIZE, PROT_READ | PROT_WRITE, MAP_SHARED,
              fd_entities_path, 0);
    if (entities == MAP_FAILED)
    {
        close (fd_entities_path);
        perror ("Error mmapping the entities file");
        exit (EXIT_FAILURE);
    }
    htab =
        mmap (0, HASH_FILESIZE, PROT_READ | PROT_WRITE, MAP_SHARED,
              fd_hash_path, 0);
    if (htab == MAP_FAILED)
    {
        close (fd_hash_path);
        perror ("Error mmapping the entities file");
        exit (EXIT_FAILURE);
    }

// End MMAP stuff


    in = fopen ("in.txt", "r");

    if (!json)
        printf ("Creating the in memory table... \n");

    num_entities = -1;
    while (1 == fscanf (in, "%[^\n]%n\n", line, &line_length))
    {                           //read one line
        char *word;
        unsigned long focal_root_entity = 0;    //Used when the Root Entity already exists
        char *ptr;
        {
            char *root = strtok_r (line, ",", &ptr);
            int i = 0;

            // First check whether the entry already exists:
            i = find_entity (root, &htab, num_entities);

            if (i > num_entities)
            {

                // Initialise this Root Entity:
                add_ent (&entities, &num_entities, root, &htab);

                focal_root_entity = num_entities;
                total_num_root_entities++;
            }
            else
            {                   //  If the root entity has been found:
                if (!json && DEBUG)
                    printf
                        ("***At line %d Root Entity %s was already found \n",
                         num_lines, root);
                num_dups++;


                focal_root_entity = i;
            }                   // if (found == 0)
        }

        for (; word = strtok_r (NULL, ",", &ptr);)
        {
            unsigned long sub_entity = 0;

            //First check whether the entity already exists :
            sub_entity = find_entity (word, &htab, num_entities);
            if (sub_entity > num_entities)
            {

                //Initialise this Sub Entity:
                add_ent (&entities, &num_entities, word, &htab);

                total_num_sub_entities++;
                sub_entity = num_entities;

            }                   //End found==0
            else
            {
                if (!json && DEBUG)
                    printf
                        ("***At line %d Sub Entity %s was already found \n",
                         num_lines, word);
                num_dups++;
            }


            // Now link the Sub Entity to the focal_root_entity using the index of the entity arrays :
            add_link (&entities[focal_root_entity], sub_entity);
            add_link (&entities[sub_entity], focal_root_entity);


        }                       // End for pos

        num_lines++;

    }                           // End while fscanf

    fclose (in);


// Now print out the entire set of Entities:



    if (json)
        printf ("[\n");
    {
        int i;
        roots = subs = 0;
        for (i = 0; i <= num_entities; i++)
        {
            int j;
            if (entities[i].num_links >= 0)
            {
                if (!json)
                    printf ("Root Entity '%s' discovered with %d sub links\n",
                            entities[i].entity_name, entities[i].num_links);
                roots++;

                for (j = 0; j <= entities[i].num_links; j++)
                {
                    if (((i > 0) || (j > 0)) && (json))
                        printf (",");
                    if (!json)
                        printf ("Sub Entity is %s\n",
                                entities[entities[i].links[j]].entity_name);
                    if (json)
                        printf
                            ("{\n   \"source\" : \"%s\",\n   \"target\" : \"%s\",\n   \"type\" : \"suit\"\n}\n",
                             entities[i].entity_name,
                             entities[entities[i].links[j]].entity_name);
                    subs++;
                }
                printf ("\n");

            }

        }
    }
    if (json)
        printf ("]\n");

    if (!json)
    {
        printf
            ("The number of root entities found were %d and the number of subs found were %d\n",
             roots, subs);
        printf
            ("The total number of Entities are %d read in %d lines with %d duplications.\n",
             num_entities, num_lines, num_dups);
    }


// Don't forget to free the mmapped memory
//
    if (munmap (entities, ENTITIES_FILESIZE) == -1)
    {
        perror ("Error un-mmapping the file");
        /* Decide here whether to close(fd) and exit() or not. Depends... */
    }
    if (munmap (htab, HASH_FILESIZE) == -1)
    {
        perror ("Error un-mmapping the file");
        /* Decide here whether to close(fd) and exit() or not. Depends... */
    }

// Un-mmaping doesn't close the file, so we still need to do that.
//
    close (fd_entities_path);
    close (fd_hash_path);


    return 0;
}
예제 #25
0
hash_alignment_block get_next_alignment_hash(maf_linear_parser parser){
   hash_alignment_block new_align = NULL;
   int in_block=0;
   int hc=0;
   long bytesread;
   int sizeLeftover=0;
   int bLoopCompleted = 0;
   char *temp;
   char *datum;
   char *npos;
   ENTRY *ret_val;
   do{
      if(parser->fill_buf){
         bytesread = fread(parser->buf+sizeLeftover, 1,
            sizeof(parser->buf)-1-sizeLeftover, parser->maf_file);
         if (bytesread<1){
            bLoopCompleted = 1;
            bytesread  = 0;
            continue;
         }
        if(ferror(parser->maf_file) != 0){
                fprintf(stderr, "File stream error: %s\nError: %s",
                   parser->filename,strerror(errno));
                return NULL;
         }
         parser->buf[sizeLeftover+bytesread]=0;
         parser->curr_pos=0;
         parser->pos=parser->buf;
         --parser->fill_buf;
     }
     npos = strchr(parser->pos,'\n');

     if(npos==NULL){
        sizeLeftover = strlen(parser->pos);
        memmove(parser->buf,parser->buf+(sizeof(parser->buf))-sizeLeftover-1,sizeLeftover);
        ++parser->fill_buf;
        continue;
     }
     *npos=0;
     datum = parser->pos;
     parser->pos = npos+1;
//If we've yet to enter an alignment block, and the first character
//of the line isn't 'a', then skip over it.
      if(!in_block && datum[0]!='a') continue;
//***HANDLE SCORE/PASS/DATA here**i
      else if(datum[0]=='a'){
//If we find an 'a' after entering a block, then this is a new block
//so rewind the file pointer and break out of read loop.
         if(in_block){
            *npos='\n';
            parser->pos = datum;
            break;
         }
//Else we're starting a new alignment block, initialize the data
//structure and set in_block to true.
         new_align=malloc(sizeof(*new_align));
         assert(new_align != NULL);
	 new_align->species = malloc(256*sizeof(char *));
         assert(new_align->species != NULL);
         new_align->sequences = calloc(1,sizeof(struct hsearch_data));
	 assert(new_align->sequences != NULL);
         hc = hcreate_r(256,new_align->sequences);
         if(hc == 0){
           fprintf(stderr,"Failed to create hash table: %s\n", strerror(errno));
           exit(1);
         }
	 new_align->size=0;
         new_align->max=128;
         new_align->data = NULL;
         in_block=1;
         continue;
      }
//If in a block and find 's', then it's a sequence to add to the
//current alignment block, parse it, reallocate alignment block's
//sequence array if necessary, and store the new sequence.
      else if(datum[0]=='s'){
         seq new_seq = get_sequence(datum);
         new_align->seq_length = new_seq->size;
         if(new_seq == NULL){
           fprintf(stderr, "Invalid sequence entry %s\n",datum);
           return NULL;
         }
         if(new_align->size >= new_align->max){
            fprintf(stderr, "WARNING: Alignment block hash table over half full"
		            "consider increasing max alignment hash size.\n"
			    "Current size: %d\nMax size: %d\n",new_align->size,
			    new_align->max);
         }temp = strdup(new_seq->src);
         assert(temp!=NULL);
         char *species_name=strtok(temp,".");
         ENTRY new_ent={species_name,new_seq};
         hc = hsearch_r(new_ent,ENTER,&ret_val,new_align->sequences);
         if(hc == 0){
           fprintf(stderr,"Failed to insert into hash table: %s\n", strerror(errno));
           exit(1);
         }if(ret_val->data != new_ent.data){
           fprintf(stderr, "Entry for species %s already present\n",species_name);
           continue;
	 }
//         printf("Entry inserted: %s\n", genome_names[i]);
         new_align->species[new_align->size++] = species_name;
         continue;
      }
//If we hit a character other than 'a' or 's', then we've exited
//the current alignment block, break out of the read loop and return
//the current alignment block.
      else break;
   }while(!bLoopCompleted);
   return new_align;
}
예제 #26
0
/*
 * MAIN
 */
int main(int argc, char *argv[]) {

    int sock_fd;
    int err;
    int optval;
    int conn;
    struct sockaddr_in *addr, *client_addr;
    socklen_t client_addr_size;
    struct hsearch_data *htab;
    pthread_t thread;
    thdata *thread_data = malloc(sizeof(thdata));

    // Create hashmap storage
    htab = calloc(1, sizeof(struct hsearch_data));
    if (hcreate_r(10000, htab) == -1) {
        printf("Error on hcreate\n");
    }

    // Create socket
    sock_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (sock_fd == -1) {
        printf("Error creating socket: %d\n", errno);
    }

    // Allow address reuse
    optval = 1;
    err = setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(int));
    if (err == -1) {
        printf("Error setting SO_REUSEADDR on socket: %d\n", errno);
    }

    // bind
    addr = calloc(1, sizeof(struct sockaddr_in));
    addr->sin_family = AF_INET;
    addr->sin_port = htons(11211);  // htons: Convert to network byte order
    addr->sin_addr.s_addr = INADDR_ANY;
    err = bind(sock_fd, (struct sockaddr *)addr, sizeof(struct sockaddr));
    free(addr);
    if (err == -1) {
        printf("bind error: %d\n", errno);
    }

    err = listen(sock_fd, 1);
    if (err == -1) {
        printf("listen error: %d\n", errno);
    }

    if (is_single(argc, argv)) {

        client_addr = malloc(sizeof(struct sockaddr_in));
        client_addr_size = sizeof(struct sockaddr);
        conn = accept(sock_fd, (struct sockaddr *)client_addr, &client_addr_size);
        free(client_addr);

        thread_data->conn = conn;
        thread_data->htab = htab;
        handle_conn(thread_data);
        close(conn);

    } else {
        while (1) {

            client_addr = malloc(sizeof(struct sockaddr_in));
            client_addr_size = sizeof(struct sockaddr);
            conn = accept(
                    sock_fd,
                    (struct sockaddr *)client_addr,
                    &client_addr_size);
            free(client_addr);

            thread_data->conn = conn;
            thread_data->htab = htab;
            pthread_create(
                    &thread,
                    NULL,
                    handle_conn,
                    thread_data);
        }
    }

    close(sock_fd);
    free(thread_data);
    hdestroy_r(htab);
    free(htab);

    return 0;
}
예제 #27
0
파일: pcflib.c 프로젝트: bt3ze/lccyao
PCFState * load_pcf_file(const char * fname, void * key0, void * key1, void *(*copy_key)(void*))
{
  FILE * input;
  PCFState * ret;
  char line[LINE_MAX];
  uint32_t icount = 0;
  uint32_t i = 0;

  ret = (PCFState*)malloc(sizeof(struct PCFState));
  check_alloc(ret);

  ret->alice_outputs = 0;
  ret->bob_outputs = 0;
  ret->inp_i = 0;
  ret->constant_keys[0] = copy_key(key0);
  ret->constant_keys[1] = copy_key(key1);
  ret->copy_key = copy_key;
  ret->call_stack = 0;
  ret->done = 0;
  ret->labels = (struct hsearch_data *)malloc(sizeof(struct hsearch_data));
  check_alloc(ret->labels);

  ret->wires = (struct wire *)malloc(1000000 * sizeof(struct wire));
  check_alloc(ret->wires);

  for(i = 0; i < 200000; i++)
    {
      ret->wires[i].flags = KNOWN_WIRE;
      ret->wires[i].value = 0;
      ret->wires[i].keydata = copy_key(key0);
    }

  memset(ret->labels, 0, sizeof(struct hsearch_data));

  ret->done = 0;
  ret->base = 1;
  ret->PC = 0;

  fprintf(stderr, "%s\n", fname);
  input = fopen(fname, "r");
  if(input == 0)
    {
      fprintf(stderr, "%s: %s\n", fname, strerror(errno));
      assert(0);
    }

  while(!feof(input))
    {
      fgets(line, LINE_MAX-1, input);
      icount++;
    }

  if(hcreate_r(icount, ret->labels) == 0)
    {
      fprintf(stderr, "Unable to allocate hash table: %s\n", strerror(errno));
      abort();
      //      exit(-1);
    }

  ret->icount = icount;
  ret->ops = (PCFOP*)malloc(icount * sizeof(PCFOP));
  check_alloc(ret->ops);

  assert(fseek(input, 0, SEEK_SET) == 0);

  icount = 0;

  while(!feof(input))
    {
      PCFOP * op;
      fgets(line, LINE_MAX-1, input);
      op = read_instr(ret, line, icount);
      ret->ops[icount] = *op;
      free(op);
      icount++;
    }

  fclose(input);

  ret->wires[0].value = 1;
  ret->wires[0].keydata = ret->copy_key(ret->constant_keys[1]);
  ret->wires[0].flags = KNOWN_WIRE;

  return ret;
}
예제 #28
0
static void sc_map_init()
{
	// initialize the map linked list
	sc_map_entries = malloc(sizeof(*sc_map_entries));
	if (sc_map_entries == NULL)
		die("Out of memory creating sc_map_entries");
	sc_map_entries->list = NULL;
	sc_map_entries->count = 0;

	// build up the map linked list

	// man 2 socket - domain
	sc_map_add(AF_UNIX);
	sc_map_add(AF_LOCAL);
	sc_map_add(AF_INET);
	sc_map_add(AF_INET6);
	sc_map_add(AF_IPX);
	sc_map_add(AF_NETLINK);
	sc_map_add(AF_X25);
	sc_map_add(AF_AX25);
	sc_map_add(AF_ATMPVC);
	sc_map_add(AF_APPLETALK);
	sc_map_add(AF_PACKET);
	sc_map_add(AF_ALG);
	// linux/can.h
	sc_map_add(AF_CAN);

	// man 2 socket - type
	sc_map_add(SOCK_STREAM);
	sc_map_add(SOCK_DGRAM);
	sc_map_add(SOCK_SEQPACKET);
	sc_map_add(SOCK_RAW);
	sc_map_add(SOCK_RDM);
	sc_map_add(SOCK_PACKET);

	// man 2 prctl
#ifndef PR_CAP_AMBIENT
#define PR_CAP_AMBIENT 47
#define PR_CAP_AMBIENT_IS_SET    1
#define PR_CAP_AMBIENT_RAISE     2
#define PR_CAP_AMBIENT_LOWER     3
#define PR_CAP_AMBIENT_CLEAR_ALL 4
#endif				// PR_CAP_AMBIENT

	sc_map_add(PR_CAP_AMBIENT);
	sc_map_add(PR_CAP_AMBIENT_RAISE);
	sc_map_add(PR_CAP_AMBIENT_LOWER);
	sc_map_add(PR_CAP_AMBIENT_IS_SET);
	sc_map_add(PR_CAP_AMBIENT_CLEAR_ALL);
	sc_map_add(PR_CAPBSET_READ);
	sc_map_add(PR_CAPBSET_DROP);
	sc_map_add(PR_SET_CHILD_SUBREAPER);
	sc_map_add(PR_GET_CHILD_SUBREAPER);
	sc_map_add(PR_SET_DUMPABLE);
	sc_map_add(PR_GET_DUMPABLE);
	sc_map_add(PR_SET_ENDIAN);
	sc_map_add(PR_GET_ENDIAN);
	sc_map_add(PR_SET_FPEMU);
	sc_map_add(PR_GET_FPEMU);
	sc_map_add(PR_SET_FPEXC);
	sc_map_add(PR_GET_FPEXC);
	sc_map_add(PR_SET_KEEPCAPS);
	sc_map_add(PR_GET_KEEPCAPS);
	sc_map_add(PR_MCE_KILL);
	sc_map_add(PR_MCE_KILL_GET);
	sc_map_add(PR_SET_MM);
	sc_map_add(PR_SET_MM_START_CODE);
	sc_map_add(PR_SET_MM_END_CODE);
	sc_map_add(PR_SET_MM_START_DATA);
	sc_map_add(PR_SET_MM_END_DATA);
	sc_map_add(PR_SET_MM_START_STACK);
	sc_map_add(PR_SET_MM_START_BRK);
	sc_map_add(PR_SET_MM_BRK);
	sc_map_add(PR_SET_MM_ARG_START);
	sc_map_add(PR_SET_MM_ARG_END);
	sc_map_add(PR_SET_MM_ENV_START);
	sc_map_add(PR_SET_MM_ENV_END);
	sc_map_add(PR_SET_MM_AUXV);
	sc_map_add(PR_SET_MM_EXE_FILE);
#ifndef PR_MPX_ENABLE_MANAGEMENT
#define PR_MPX_ENABLE_MANAGEMENT 43
#endif				// PR_MPX_ENABLE_MANAGEMENT
	sc_map_add(PR_MPX_ENABLE_MANAGEMENT);
#ifndef PR_MPX_DISABLE_MANAGEMENT
#define PR_MPX_DISABLE_MANAGEMENT 44
#endif				// PR_MPX_DISABLE_MANAGEMENT
	sc_map_add(PR_MPX_DISABLE_MANAGEMENT);
	sc_map_add(PR_SET_NAME);
	sc_map_add(PR_GET_NAME);
	sc_map_add(PR_SET_NO_NEW_PRIVS);
	sc_map_add(PR_GET_NO_NEW_PRIVS);
	sc_map_add(PR_SET_PDEATHSIG);
	sc_map_add(PR_GET_PDEATHSIG);
	sc_map_add(PR_SET_PTRACER);
	sc_map_add(PR_SET_SECCOMP);
	sc_map_add(PR_GET_SECCOMP);
	sc_map_add(PR_SET_SECUREBITS);
	sc_map_add(PR_GET_SECUREBITS);
#ifndef PR_SET_THP_DISABLE
#define PR_SET_THP_DISABLE 41
#endif				// PR_SET_THP_DISABLE
	sc_map_add(PR_SET_THP_DISABLE);
	sc_map_add(PR_TASK_PERF_EVENTS_DISABLE);
	sc_map_add(PR_TASK_PERF_EVENTS_ENABLE);
#ifndef PR_GET_THP_DISABLE
#define PR_GET_THP_DISABLE 42
#endif				// PR_GET_THP_DISABLE
	sc_map_add(PR_GET_THP_DISABLE);
	sc_map_add(PR_GET_TID_ADDRESS);
	sc_map_add(PR_SET_TIMERSLACK);
	sc_map_add(PR_GET_TIMERSLACK);
	sc_map_add(PR_SET_TIMING);
	sc_map_add(PR_GET_TIMING);
	sc_map_add(PR_SET_TSC);
	sc_map_add(PR_GET_TSC);
	sc_map_add(PR_SET_UNALIGN);
	sc_map_add(PR_GET_UNALIGN);

	// man 2 getpriority
	sc_map_add(PRIO_PROCESS);
	sc_map_add(PRIO_PGRP);
	sc_map_add(PRIO_USER);

	// man 2 setns
	sc_map_add(CLONE_NEWIPC);
	sc_map_add(CLONE_NEWNET);
	sc_map_add(CLONE_NEWNS);
	sc_map_add(CLONE_NEWPID);
	sc_map_add(CLONE_NEWUSER);
	sc_map_add(CLONE_NEWUTS);

	// initialize the htab for our map
	memset((void *)&sc_map_htab, 0, sizeof(sc_map_htab));
	if (hcreate_r(sc_map_entries->count, &sc_map_htab) == 0)
		die("could not create map");

	// add elements from linked list to map
	struct sc_map_entry *p = sc_map_entries->list;
	while (p != NULL) {
		errno = 0;
		if (hsearch_r(*p->e, ENTER, &p->ep, &sc_map_htab) == 0)
			die("hsearch_r failed");

		if (&p->ep == NULL)
			die("could not initialize map");

		p = p->next;
	}
}
예제 #29
0
void init_store(void) {
    store = calloc(1, sizeof(struct hsearch_data));
    hcreate_r(100, store);
}
예제 #30
0
int
main (int argc, char *argv[])
{
    char line[1000000];
    FILE *in, *out;
    int line_length;
    int total_num_root_entities;
    int total_num_sub_entities;
    int num_entities;
    unsigned long *temp;
    int index;
    int ret;
    int roots, subs;
    int json = 1;

    if (hcreate_r (200000, &htab) == 0)
    {
        perror ("Failed to create hash");
        exit (1);
    }

    struct entity *entities = 0;


    in = fopen ("in.txt", "r");
    out = fopen ("out.txt", "w");


    num_entities = -1;
    while (1 == fscanf (in, "%[^\n]%n\n", line, &line_length))
    {                           //read one line
        char *word;
        struct entity *focal_root = 0;  //Used when the Root Entity already exists
        char *ptr;
        {
            char *root = strtok_r (line, ",", &ptr);
            int i = 0;

            // First check whether the entry already exists:
            focal_root = find_entity (entities, num_entities, root);

            if (focal_root == NULL)
            {

                // Initialise this Root Entity:
                focal_root = add_ent (root);

                fprintf (out, "%s\n", root);

                total_num_root_entities++;
            }
        }

        for (; word = strtok_r (NULL, ",", &ptr);)
        {
            struct entity *entity = 0;

            //First check whether the entity already exists :
            entity = find_entity (entities, num_entities, word);
            if (entity == NULL)
            {

                //Initialise this Sub Entity:
                entity = add_ent (word);
            }

            // Now link the Sub Entity to the focal_root_entity using the index of the entity arrays :
            add_link (focal_root, entity);
            add_link (entity, focal_root);

            // Echo the word to the o/p file :
            fprintf (out, "%s\n", word);

        }                       // End for pos
    }
    fclose (out);
    fclose (in);


// Now print out the entire set of Entities:



    if (json)
        printf ("[\n");
    {
        int i;
        roots = subs = 0;
        for (i = 0; i <= num_entities; i++)
        {
            int j;
            if (entities[i].num_links >= 0)
            {
                if (!json)
                    printf ("Root Entity '%s' discovered with %d sub links\n",
                            entities[i].entity_name, entities[i].num_links);
                roots++;

                for (j = 0; j <= entities[i].num_links; j++)
                {
                    if (((i > 0) || (j > 0)) && (json))
                        printf (",");
                    if (!json)
                        printf ("Sub Entity is %s\n",
                                entities[entities[i].links[j]].entity_name);
                    if (json)
                        printf
                            ("{\n   \"source\" : \"%s\",\n   \"target\" : \"%s\",\n   \"type\" : \"suit\"\n}\n",
                             entities[i].entity_name,
                             entities[entities[i].links[j]].entity_name);
                    subs++;
                }
                printf ("\n");

            }

        }
    }
    if (json)
        printf ("]\n");

    if (!json)
    {
        printf
            ("The number of root entities found were %d and the number of subs found were %d\n",
             roots, subs);
        printf ("The total number of Entities are %d\n", num_entities);
        printf ("The total number of Root Entities are %d\n",
                total_num_root_entities);
        printf ("The total number of Sub Entities are %d\n",
                total_num_sub_entities);
    }




    hdestroy_r (&htab);


    return (0);
// fwrite the array of structs out to save them:
    out = fopen ("entities.bin", "wb");
    ret = fwrite (entities, sizeof (entities), 1, out);
    fclose (out);

// fread the array of structs in test:
    in = fopen ("entities.bin", "rb");
    ret = fread (entities, sizeof (entities), 1, in);
    fclose (in);

    return 0;
}