Exemple #1
0
static void
print_tag(tag_t *tag, char *name)
{
    tag_t	*base;
    tag_t	*temp;
    record_t	*record;

    if (tag->type & type_unsigned)
	printf("unsigned");
    else if (tag->type & type_struct)
	printf("struct");
    else if (tag->type & type_union)
	printf("union");
    for (base = tag; base->tag; base = base->tag)
	;
    record = base->name;
    if (record->name) {
	if (tag->type & (type_unsigned | type_struct | type_union))
	    putchar(' ');
	printf("%s", record->name->name.string);
    }
    if ((tag->type & type_struct) || (tag->type & type_union))
	print_fields(record);
    for (temp = tag; temp != base; temp = temp->tag)
	if (type_mask(temp->type) != type_vector)
	    printf(" %s", (char *)temp->name);
    if (name)
	printf(" %s", name);
    for (temp = tag; temp != base; temp = temp->tag)
	if (type_mask(temp->type) == type_vector)
	    printf(" [ %s ]", (char *)temp->name);
}
Exemple #2
0
/* print a struct */
void print_struct(Struct *s)
{
    fppush();
    printf("Type: %d\nDataOrDataOffset: %d\nField Count: %d\n",
           s->Type, s->DataOrDataOffset, s->FieldCount);
    print_fields(s);
    fppop();
}
gboolean
print_dhcp6_config (NMDHCP6Config *dhcp6, NmCli *nmc, const char *group_prefix)
{
	GHashTable *table;
	guint32 mode_flag = (nmc->print_output == NMC_PRINT_PRETTY) ? NMC_PF_FLAG_PRETTY : (nmc->print_output == NMC_PRINT_TERSE) ? NMC_PF_FLAG_TERSE : 0;
	guint32 multiline_flag = nmc->multiline_output ? NMC_PF_FLAG_MULTILINE : 0;
	guint32 escape_flag = nmc->escape_values ? NMC_PF_FLAG_ESCAPE : 0;

	if (dhcp6 == NULL)
		return FALSE;

	table = nm_dhcp6_config_get_options (dhcp6);
	if (table) {
		GHashTableIter table_iter;
		gpointer key, value;
		char **options_arr = NULL;
		int i = 0;

		nmc->allowed_fields = nmc_fields_dhcp6_config;
		nmc->print_fields.flags = multiline_flag | mode_flag | escape_flag | NMC_PF_FLAG_FIELD_NAMES;
		nmc->print_fields.indices = parse_output_fields (NMC_FIELDS_DHCP6_CONFIG_ALL, nmc->allowed_fields, NULL);
		print_fields (nmc->print_fields, nmc->allowed_fields); /* Print header */

		options_arr = g_new (char *, g_hash_table_size (table) + 1);
		g_hash_table_iter_init (&table_iter, table);
		while (g_hash_table_iter_next (&table_iter, &key, &value))
			options_arr[i++] = g_strdup_printf ("%s = %s", (char *) key, (char *) value);
		options_arr[i] = NULL;

		set_val_str (nmc->allowed_fields, 0, group_prefix);
		set_val_arr (nmc->allowed_fields, 1, (const char **) options_arr);

		nmc->print_fields.flags = multiline_flag | mode_flag | escape_flag | NMC_PF_FLAG_SECTION_PREFIX;
		print_fields (nmc->print_fields, nmc->allowed_fields); /* Print values */

		g_strfreev (options_arr);

		return TRUE;
	}
	return FALSE;
}
void cpp_idt::print(std::ostream &out, unsigned indent) const
{
  print_fields(out, indent);

  if(!sub.empty())
  {
    for(cpp_id_mapt::const_iterator it=sub.begin();
        it!=sub.end();
        it++)
      it->second.print(out, indent+2);

    out << std::endl;
  }
}
Exemple #5
0
int main() {
    FILE *fp = NULL;
    char *line1 = NULL;
    char *lines = NULL;
    char line[LINE_SIZE];
    int len = 0;
    char *tap = NULL;
    int offset = 0;
    int st_index = 0;
    int halt_index = 0;
    char *st_info = NULL;
    int read = 0;
    int file_offset = 0;
    int total_bytes = 0;

    fp = fopen("file.txt", "r");
    fgets(line, 10, fp);
    chomp_new_line(line, &len);
    tap = malloc(sizeof(char) * len);
    strncpy(tap, line, len);
    printf("Tape: %s\n", tap);

    fgets(line, 10, fp);
    offset = atoi(line);
    printf("Offset: %d\n", offset);

    fgets(line, 10, fp);
    st_index = atoi(line);
    printf("Start Index: %d\n", st_index);

    fgets(line, 10, fp);
    halt_index = atoi(line);
    printf("Halt Index: %d\n", halt_index);

    file_offset = ftell(fp);
    fseek(fp, 0, SEEK_END);
    total_bytes = ftell(fp);
    total_bytes = total_bytes - file_offset;
    fseek(fp, file_offset, SEEK_SET);
    lines = malloc(sizeof(char) * total_bytes);
    fread(lines, 1, total_bytes, fp);
    printf("%s ", lines);

    line1 = strtok(lines, "\n");
    while (line1) {
        print_fields(line1);
        line1 = strtok(NULL, "\n");
    }

}
Exemple #6
0
int main() {
  char* tests[] = {
    "hello",
    "field1,field2",
    ",f",
    "",
    ",,,,",
    NULL
  };

  int i;
  for(i = 0; tests[i] != NULL; i++) { 
    printf("split('%s') -> ", tests[i]);
    // you need the strdup since we modify the string in place
    int nf = split_csv(strdup(tests[i]));
    printf("%d fields\n", nf);
    print_fields();
  }
}
Exemple #7
0
int _do_stat(uint32_t jobid, uint32_t stepid, char *nodelist,
	     uint32_t req_cpufreq)
{
	job_step_stat_response_msg_t *step_stat_response = NULL;
	int rc = SLURM_SUCCESS;
	ListIterator itr;
	slurmdb_stats_t temp_stats;
	job_step_stat_t *step_stat = NULL;
	int ntasks = 0;
	int tot_tasks = 0;
	hostlist_t hl = NULL;

	debug("requesting info for job %u.%u", jobid, stepid);
	if ((rc = slurm_job_step_stat(jobid, stepid, nodelist,
				      &step_stat_response)) != SLURM_SUCCESS) {
		if (rc == ESLURM_INVALID_JOB_ID) {
			debug("job step %u.%u has already completed",
			      jobid, stepid);
		} else {
			error("problem getting step_layout for %u.%u: %s",
			      jobid, stepid, slurm_strerror(rc));
		}
		return rc;
	}

	memset(&job, 0, sizeof(slurmdb_job_rec_t));
	job.jobid = jobid;

	memset(&step, 0, sizeof(slurmdb_step_rec_t));

	memset(&temp_stats, 0, sizeof(slurmdb_stats_t));
	temp_stats.cpu_min = NO_VAL;
	memset(&step.stats, 0, sizeof(slurmdb_stats_t));
	step.stats.cpu_min = NO_VAL;

	step.job_ptr = &job;
	step.stepid = stepid;
	step.nodes = xmalloc(BUF_SIZE);
	step.req_cpufreq = req_cpufreq;
	step.stepname = NULL;
	step.state = JOB_RUNNING;

	hl = hostlist_create(NULL);
	itr = list_iterator_create(step_stat_response->stats_list);
	while ((step_stat = list_next(itr))) {
		if (!step_stat->step_pids || !step_stat->step_pids->node_name)
			continue;
		if (step_stat->step_pids->pid_cnt > 0 ) {
			int i;
			for(i=0; i<step_stat->step_pids->pid_cnt; i++) {
				if (step.pid_str)
					xstrcat(step.pid_str, ",");
				xstrfmtcat(step.pid_str, "%u",
					   step_stat->step_pids->pid[i]);
			}
		}

		if (params.pid_format) {
			step.nodes = step_stat->step_pids->node_name;
			print_fields(&step);
			xfree(step.pid_str);
		} else {
			hostlist_push(hl, step_stat->step_pids->node_name);
			jobacctinfo_2_stats(&temp_stats, step_stat->jobacct);
			ntasks += step_stat->num_tasks;
			aggregate_stats(&step.stats, &temp_stats);
		}
	}
	list_iterator_destroy(itr);
	slurm_job_step_pids_response_msg_free(step_stat_response);
	/* we printed it out already */
	if (params.pid_format)
		return rc;

	hostlist_sort(hl);
	hostlist_ranged_string(hl, BUF_SIZE, step.nodes);
	hostlist_destroy(hl);
	tot_tasks += ntasks;

	if (tot_tasks) {
		step.stats.cpu_ave /= (double)tot_tasks;
		step.stats.rss_ave /= (double)tot_tasks;
		step.stats.vsize_ave /= (double)tot_tasks;
		step.stats.pages_ave /= (double)tot_tasks;
		step.stats.disk_read_ave /= (double)tot_tasks;
		step.stats.disk_write_ave /= (double)tot_tasks;
		step.stats.act_cpufreq /= (double)tot_tasks;
		step.ntasks = tot_tasks;
	}

	print_fields(&step);

	return rc;
}
gboolean
print_ip4_config (NMIP4Config *cfg4, NmCli *nmc, const char *group_prefix)
{
	GSList *list, *iter;
	const GArray *array;
	const GPtrArray *ptr_array;
	char **addr_arr = NULL;
	char **route_arr = NULL;
	char **dns_arr = NULL;
	char **domain_arr = NULL;
	char **wins_arr = NULL;
	int i = 0;
	guint32 mode_flag = (nmc->print_output == NMC_PRINT_PRETTY) ? NMC_PF_FLAG_PRETTY : (nmc->print_output == NMC_PRINT_TERSE) ? NMC_PF_FLAG_TERSE : 0;
	guint32 multiline_flag = nmc->multiline_output ? NMC_PF_FLAG_MULTILINE : 0;
	guint32 escape_flag = nmc->escape_values ? NMC_PF_FLAG_ESCAPE : 0;

	if (cfg4 == NULL)
		return FALSE;

	nmc->allowed_fields = nmc_fields_ip4_config;
	nmc->print_fields.flags = multiline_flag | mode_flag | escape_flag | NMC_PF_FLAG_FIELD_NAMES;
	nmc->print_fields.indices = parse_output_fields (NMC_FIELDS_IP4_CONFIG_ALL, nmc->allowed_fields, NULL);
	print_fields (nmc->print_fields, nmc->allowed_fields); /* Print header */

	/* addresses */
	list = (GSList *) nm_ip4_config_get_addresses (cfg4);
	addr_arr = g_new (char *, g_slist_length (list) + 1);
	for (iter = list; iter; iter = g_slist_next (iter)) {
		NMIP4Address *addr = (NMIP4Address *) iter->data;
		guint32 prefix;
		char *ip_str, *gw_str;

		ip_str = nmc_ip4_address_as_string (nm_ip4_address_get_address (addr), NULL);
		prefix = nm_ip4_address_get_prefix (addr);
		gw_str = nmc_ip4_address_as_string (nm_ip4_address_get_gateway (addr), NULL);

		addr_arr[i++] = g_strdup_printf ("ip = %s/%u, gw = %s", ip_str, prefix, gw_str);
		g_free (ip_str);
		g_free (gw_str);
	}
	addr_arr[i] = NULL;

	/* routes */
	list = (GSList *) nm_ip4_config_get_routes (cfg4);
	route_arr = g_new (char *, g_slist_length (list) + 1);
	i = 0;
	for (iter = list; iter; iter = g_slist_next (iter)) {
		NMIP4Route *route = (NMIP4Route *) iter->data;
		guint32 prefix, metric;
		char *dest_str, *nexthop_str;

		dest_str = nmc_ip4_address_as_string (nm_ip4_route_get_dest (route), NULL);
		nexthop_str = nmc_ip4_address_as_string (nm_ip4_route_get_next_hop (route), NULL);
		prefix = nm_ip4_route_get_prefix (route);
		metric = nm_ip4_route_get_metric (route);

		route_arr[i++] = g_strdup_printf ("dst = %s/%u, nh = %s, mt = %u", dest_str, prefix, nexthop_str, metric);
		g_free (dest_str);
		g_free (nexthop_str);
	}
	route_arr[i] = NULL;

	/* DNS */
	array = nm_ip4_config_get_nameservers (cfg4);
	if (array) {
		dns_arr = g_new (char *, array->len + 1);
		for (i = 0; i < array->len; i++)
			dns_arr[i] = nmc_ip4_address_as_string (g_array_index (array, guint32, i), NULL);

		dns_arr[i] = NULL;
	}

	/* domains */
	ptr_array = nm_ip4_config_get_domains (cfg4);
	if (ptr_array) {
		domain_arr = g_new (char *, ptr_array->len + 1);
		for (i = 0; i < ptr_array->len; i++)
			domain_arr[i] = g_ptr_array_index (ptr_array, i);

		domain_arr[i] = NULL;
	}

	/* WINS */
	array = nm_ip4_config_get_wins_servers (cfg4);
	if (array) {
		wins_arr = g_new (char *, array->len + 1);
		for (i = 0; i < array->len; i++)
			wins_arr[i] = nmc_ip4_address_as_string (g_array_index (array, guint32, i), NULL);

		wins_arr[i] = NULL;
	}

	set_val_str (nmc->allowed_fields, 0, group_prefix);
	set_val_arr (nmc->allowed_fields, 1, (const char **) addr_arr);
	set_val_arr (nmc->allowed_fields, 2, (const char **) route_arr);
	set_val_arr (nmc->allowed_fields, 3, (const char **) dns_arr);
	set_val_arr (nmc->allowed_fields, 4, (const char **) domain_arr);
	set_val_arr (nmc->allowed_fields, 5, (const char **) wins_arr);

	nmc->print_fields.flags = multiline_flag | mode_flag | escape_flag | NMC_PF_FLAG_SECTION_PREFIX;
	print_fields (nmc->print_fields, nmc->allowed_fields); /* Print values */

	g_strfreev (addr_arr);
	g_strfreev (route_arr);
	g_strfreev (dns_arr);
	g_free (domain_arr);
	g_strfreev (wins_arr);

	return TRUE;
}
Exemple #9
0
void
cmd_ls(struct fcrondyn_cl *client, long int *cmd, int fd, int is_root)
    /* run a command which lists some jobs */
{
    int found = 0;
    int all = (cmd[1] == ALL) ? 1 : 0;
    char *user = NULL;
    struct job_t *j;
    int i;
    unsigned char fields[FIELD_NUM_SIZE];

    for (i = 0; i < FIELD_NUM_SIZE; i++)
	fields[i] = 0;
    
    switch ( cmd[0] ) {
    case CMD_DETAILS:
	bit_set(fields, FIELD_SCHEDULE);
	bit_set(fields, FIELD_RQ);
	bit_set(fields, FIELD_USER);
	bit_set(fields, FIELD_OPTIONS);
	print_fields(fd, fields);
	for ( j = queue_base; j != NULL; j = j->j_next ) {
	    if ( cmd[1] == j->j_line->cl_id ) {
		if (strcmp(client->fcl_user, j->j_line->cl_file->cf_user) == 0
		    || is_root )
		    print_line(fd, j->j_line, fields, 0, 0, 0);
		else
		    Send_err_msg(fd, err_job_nallowed_str);
		found = 1;
		break;
	    }
	}
	break;

    case CMD_LIST_JOBS:
    case CMD_LIST_LAVGQ:
    case CMD_LIST_SERIALQ:
    case CMD_LIST_EXEQ:
	if ( cmd[0] == CMD_LIST_LAVGQ ) {
	    double lavg[3] = {0, 0, 0};
	    char lavg_str[TERM_LEN];
	    getloadavg(lavg, 3);
	    i = snprintf(lavg_str, sizeof(lavg_str), "Current load average : "
			 "%.1f, %.1f, %.1f\n", lavg[0], lavg[1], lavg[2]);
	    send(fd, lavg_str, i, 0);

	    bit_set(fields, FIELD_LAVG);
	}
	else
	    bit_set(fields, FIELD_SCHEDULE);

	if ( cmd[0] == CMD_LIST_SERIALQ )
	    bit_set(fields, FIELD_INDEX);

	if ( cmd[0] == CMD_LIST_EXEQ )
	    bit_set(fields, FIELD_PID);

	if ( all && ! is_root) {
	    warn("User %s tried to list *all* jobs.", client->fcl_user);
	    Send_err_msg_end(fd, err_all_nallowed_str);
	}
	if ( all )
	    bit_set(fields, FIELD_USER);
	print_fields(fd, fields);

	if (! all) {
	    struct passwd *pass;
	    
#ifdef SYSFCRONTAB
	    if ( cmd[1] == SYSFCRONTAB_UID )
		user = SYSFCRONTAB;
	    else {
#endif
		if ( (pass = getpwuid( (uid_t) cmd[1] )) == NULL ) {
		    warn_e("Unable to find passwd entry for %ld", cmd[1]);
		    Send_err_msg_end(fd, err_invalid_user_str);
		}
		if ( ! is_root && strcmp(pass->pw_name, client->fcl_user) != 0 ) {
		    warn_e("%s is not allowed to see %s's jobs. %ld", client->fcl_user,
			   pass->pw_name);
		    Send_err_msg_end(fd, err_others_nallowed_str);
		}
		user = pass->pw_name;
#ifdef SYSFCRONTAB
	    }
#endif
	}

	/* list all jobs one by one and find the corresponding ones */
	switch ( cmd[0] ) {
	case CMD_LIST_JOBS:
	    for ( j = queue_base; j != NULL; j = j->j_next )
		Test_line(j->j_line, 0, 0, 0);
	    break;

	case CMD_LIST_EXEQ:
	    for ( i = 0; i < exe_num; i++)
		Test_line(exe_array[i].e_line, exe_array[i].e_job_pid, 0, 0);
	    break;

	case CMD_LIST_LAVGQ:
	    for ( i = 0; i < lavg_num; i++)
		Test_line(lavg_array[i].l_line, 0, 0, lavg_array[i].l_until);
	    break;

	case CMD_LIST_SERIALQ:
	{
	    int j;
	    i = serial_array_index;
	    for ( j = 0; j < serial_num; j++ ) {
		Test_line(serial_array[i], 0, j, 0);
		if ( ++i >= serial_array_size )
		    i -= serial_array_size;
	    }
	    break;
	}

	}
	
	break;
    }

    if ( ! found )
	Send_err_msg(fd, err_job_nfound_str);
    /* to tell fcrondyn there's no more data to wait */
    Tell_no_more_data(fd);
    
}