bool NoximGlobalTrafficTable::load(const char *fname)
{
  // Open file
  ifstream fin(fname, ios::in);
  if (!fin)
    return false;

  // Initialize variables
  traffic_table.clear();

  // Cycle reading file
  while (!fin.eof()) {
    char line[512];
    fin.getline(line, sizeof(line) - 1);

    if (line[0] != '\0') {
      if (line[0] != '%') {
	int src, dst;	// Mandatory
	float pir, por;
	int t_on, t_off, t_period;
	int t_use_lvp;

	int params =
	  sscanf(line, "%d %d %d %f %f %d %d %d", &src, &dst, &t_use_lvp, &pir,
		 &por, &t_on, &t_off, &t_period);
	if (params >= 2) {
	  // Create a communication from the parameters read on the line
	  NoximCommunication communication;

	  // Mandatory fields
	  communication.src = src;
	  communication.dst = dst;

	  // Use low voltage path
	  if (params >= 3 && t_use_lvp == 1)
	    communication.use_low_voltage_path = true;
	  else
	    communication.use_low_voltage_path = false;

	  // Custom PIR
	  if (params >= 4 && pir >= 0 && pir <= 1)
	    communication.pir = pir;
	  else
	    communication.pir =
	      NoximGlobalParams::packet_injection_rate;

	  // Custom POR
	  if (params >= 5 && por >= 0 && por <= 1)
	    communication.por = por;
	  else
	    communication.por = communication.pir;	// NoximGlobalParams::probability_of_retransmission;

	  // Custom Ton
	  if (params >= 6 && t_on >= 0)
	    communication.t_on = t_on;
	  else
	    communication.t_on = 0;

	  // Custom Toff
	  if (params >= 7 && t_off >= 0) {
	    assert(t_off > t_on);
	    communication.t_off = t_off;
	  } else
	    communication.t_off =
	      DEFAULT_RESET_TIME +
	      NoximGlobalParams::simulation_time;

	  // Custom Tperiod
	  if (params >= 8 && t_period > 0) {
	    assert(t_period > t_off);
	    communication.t_period = t_period;
	  } else
	    communication.t_period =
	      DEFAULT_RESET_TIME +
	      NoximGlobalParams::simulation_time;

	  // Add this communication to the vector of communications
	  traffic_table.push_back(communication);
	}
      }
    }
  }

  return true;
}
Exemplo n.º 2
0
Arquivo: main.c Projeto: gygy/asuswrt
static void
init_from_conf_file()
{
    FILE   *conf_file;
    char   *line = NULL;
    #define LINEBUFLEN 256
    char    var[LINEBUFLEN];
    char    val[LINEBUFLEN];
    size_t  len  = 0;
    ssize_t numread;
    int     assigns;
    char    default_icon_path[] = {"/rom/etc/icon.ico"};
#ifdef RTCONFIG_RALINK
    char    default_wl_interface[] = {"ra0"};
#else
    char    default_wl_interface[] = {"eth1"};
#endif

    /* Set default values for configuration options */
    /* (avoid strdup() since it doesn't use xmalloc wrapper) */
    g_icon_path = xmalloc(strlen(default_icon_path)+1);
    strcpy(g_icon_path,default_icon_path);

    /* Examine configuration file, if it exists */
    conf_file = fopen("/rom/etc/lld2d.conf", "r");
    if (conf_file == NULL)  return;
    while ((numread = getline(&line, &len, conf_file)) != -1)
    {
        var[0] = val[0] = '\0';
        assigns = sscanf(line, "%s = %s", var, val);

        if (assigns==2)
        {
            /* compare to each of the 2 allowed vars... */
            if (!strcmp(var,"icon")) {
                char *path = NULL;
                char *cur  = NULL;

                path = xmalloc(strlen(val)+6); // always allow enough room for a possible prefix of '/etc/'
                cur = path;

                /* Check for leading '/' and prefix '/etc/' if missing */
                if (val[0] != '/')
                {
                    strcpy(cur,"/etc/"); cur += 5;
                }
                strncpy(cur,val,strlen(val));

                if (g_icon_path) xfree(g_icon_path);	// always use the most recent occurrence
                g_icon_path = path;
                DEBUG({printf("configvar 'g_icon_path' = %s\n", g_icon_path);})
            } else if (!strcmp(var,"jumbo-icon")) {
                char *path = NULL;
                char *cur  = NULL;

                path = xmalloc(strlen(val)+6); // always allow enough room for a possible prefix of '/etc/'
                cur = path;

                /* Check for leading '/' and prefix '/etc/' if missing */
                if (val[0] != '/')
                {
                    strcpy(cur,"/etc/"); cur += 5;
                }
                strncpy(cur,val,strlen(val));

                if (g_jumbo_icon_path) xfree(g_jumbo_icon_path);	// always use the most recent occurrence
                g_jumbo_icon_path = path;
                DEBUG({printf("configvar 'g_jumbo_icon_path' = %s\n", g_jumbo_icon_path);})
            } else if (!strcmp(var, "wl-interface")) {	/* patch here for wireless interface config file, bobtseng 2007.9.7. */
Exemplo n.º 3
0
network_connect(struct scpi_instrument *scpi)
{
	struct sockaddr_in MyAddress, MyControlAddress;
	int status;
	struct timeval timeout;
	char buf[128];

	timeout.tv_sec = SOCKETS_TIMEOUT;
	timeout.tv_usec = 0;

	/* Create socket (allocate resources) - IPv4, TCP */
	scpi->main_socket = socket(PF_INET, SOCK_STREAM, 0);

	if (scpi->main_socket == -1) {
		printf("Error: Unable to create socket (%i)...\n",errno);
		return -1;
	}

	/* set Recieve and Transmit Timeout, so connect doesn't take so long to fail */
	status = setsockopt(scpi->main_socket, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout));
	if (status < 0)
		perror("setsockopt failed\n");

	status = setsockopt(scpi->main_socket, SOL_SOCKET, SO_SNDTIMEO, (char *)&timeout,sizeof(timeout));
	if (status < 0)
		perror("setsockopt failed\n");

	/* Establish TCP connection */
	memset(&MyAddress,0,sizeof(struct sockaddr_in));
	MyAddress.sin_family = PF_INET;
	MyAddress.sin_port = htons(scpi->main_port);
	MyAddress.sin_addr.s_addr = inet_addr(scpi->ip_address);

	status = connect(scpi->main_socket, (struct sockaddr *)&MyAddress, sizeof(struct sockaddr_in));
	if(status == -1) {
		printf("Error: Unable to establish connection to ip:%s (%i)...\n",
				scpi->ip_address, errno);
		return -1;
	}

	/* Minimize latency by setting TCP_NODELAY option */
	network_setnodelay(scpi->main_socket);

	/* Ask for control port */
	sprintf(buf, "SYST:COMM:TCPIP:CONTROL?\n");
	status = send(scpi->main_socket, buf, strlen(buf), 0);
	if (status == -1)
		return -1;

	if (scpi_network_read((scpi)) == 0) {
		scpi->control_socket = scpi->main_socket;
		return 0;
	}

	sscanf(scpi->response, "%" SCNd16, &scpi->control_port);

	/* Create socket for control port */
	scpi->control_socket = socket(PF_INET, SOCK_STREAM, 0);
	if(scpi->control_socket == -1) {
		printf("Error: Unable to create control port socket (%i)...\n",errno);
		return -1;
	}

	/* Establish TCP connection to control port */
	memset(&MyControlAddress, 0, sizeof(struct sockaddr_in));
	MyControlAddress.sin_family = PF_INET;
	MyControlAddress.sin_port = htons(scpi->control_port);
	MyControlAddress.sin_addr.s_addr = inet_addr(scpi->ip_address);

	status = connect(scpi->control_socket, (struct sockaddr *) &MyControlAddress, sizeof(struct sockaddr_in));
	if(status == -1) {
		printf("Error: Unable to establish connection to control port (%i)...\n",
			errno);
		return -1;
	}

	return 0;
}
Exemplo n.º 4
0
/**
 * Process counter data and dispatch values
 */
static int node_handler_fetch_data(void *arg, const char *val, const char *key)
{
    value_t uv;
    double tmp_d;
    uint64_t tmp_u;
    struct values_tmp *vtmp = (struct values_tmp*) arg;
    uint32_t type = DSET_TYPE_UNFOUND;
    int index = vtmp->index;

    char ds_name[DATA_MAX_NAME_LEN];
    memset(ds_name, 0, sizeof(ds_name));

    if(parse_keys(key, ds_name))
    {
        return 1;
    }

    if(index >= vtmp->d->ds_num)
    {
        //don't overflow bounds of array
        index = (vtmp->d->ds_num - 1);
    }

    /**
     * counters should remain in same order we parsed schema... we maintain the
     * index variable to keep track of current point in list of counters. first
     * use index to guess point in array for retrieving type. if that doesn't
     * work, use the old way to get the counter type
     */
    if(strcmp(ds_name, vtmp->d->ds_names[index]) == 0)
    {
        //found match
        type = vtmp->d->ds_types[index];
    }
    else if((index > 0) && (strcmp(ds_name, vtmp->d->ds_names[index-1]) == 0))
    {
        //try previous key
        type = vtmp->d->ds_types[index-1];
    }

    if(type == DSET_TYPE_UNFOUND)
    {
        //couldn't find right type by guessing, check the old way
        type = backup_search_for_type(vtmp->d, ds_name);
    }

    switch(type)
    {
        case DSET_LATENCY:
            if(vtmp->avgcount_exists == -1)
            {
                sscanf(val, "%" PRIu64, &vtmp->avgcount);
                vtmp->avgcount_exists = 0;
                //return after saving avgcount - don't dispatch value
                //until latency calculation
                return 0;
            }
            else
            {
                double sum, result;
                sscanf(val, "%lf", &sum);

                if(vtmp->avgcount == 0)
                {
                    vtmp->avgcount = 1;
                }

                /** User wants latency values as long run avg */
                if(long_run_latency_avg)
                {
                    result = (sum / vtmp->avgcount);
                }
                else
                {
                    result = get_last_avg(vtmp->d, ds_name, vtmp->latency_index, sum, vtmp->avgcount);
                    if(result == -ENOMEM)
                    {
                        return -ENOMEM;
                    }
                }

                uv.gauge = result;
                vtmp->avgcount_exists = -1;
                vtmp->latency_index = (vtmp->latency_index + 1);
            }
            break;
        case DSET_BYTES:
            sscanf(val, "%lf", &tmp_d);
            uv.gauge = tmp_d;
            break;
        case DSET_RATE:
            sscanf(val, "%" PRIu64, &tmp_u);
            uv.derive = tmp_u;
            break;
        case DSET_TYPE_UNFOUND:
        default:
            ERROR("ceph plugin: ds %s was not properly initialized.", ds_name);
            return -1;
    }

    sstrncpy(vtmp->vlist.type, ceph_dset_types[type], sizeof(vtmp->vlist.type));
    sstrncpy(vtmp->vlist.type_instance, ds_name, sizeof(vtmp->vlist.type_instance));
    vtmp->vlist.values = &uv;
    vtmp->vlist.values_len = 1;

    vtmp->index = (vtmp->index + 1);
    plugin_dispatch_values(&vtmp->vlist);

    return 0;
}
Exemplo n.º 5
0
/*****************************************************************************
*Name         :
*Description  :receive testcase num from echo command
*Parameter    :
*Return       :
*Note         :
*****************************************************************************/
static ssize_t nand_test_store(struct kobject *kobject,struct attribute *attr, const char *buf, size_t count)
{
    int             ret;
    int             argnum = 0;
    char            cmd[32] = {0};
    unsigned int    param0 = 0;
    unsigned int    param1 = 0;
    unsigned int    param2 = 0;

    struct nand_kobject* nand_kobj;
    nand_kobj = (struct nand_kobject*)kobject;

    argnum = sscanf(buf, "%s %u %u %u ", cmd, &param0, &param1, &param2);
    printk("argnum=%i, cmd=%s, param0=%u, param1=%u, param2=%u\n", argnum, cmd, param0, param1, param2);

    if (-1 == argnum)
    {
        printk("cmd format err!");
        goto NAND_TEST_STORE_EXIT;
    }

    if(strcmp(cmd,"help") == 0)
    {
        printk("nand debug cmd:\n");
        printk("  help \n");
    }
    else if(strcmp(cmd,"flush") == 0)
    {
        printk("nand debug cmd:\n");
        printk("  flush \n");
        mutex_lock(nand_kobj->nftl_blk->blk_lock);
        ret = nand_kobj->nftl_blk->flush_write_cache(nand_kobj->nftl_blk,param0);
        mutex_unlock(nand_kobj->nftl_blk->blk_lock);
        goto NAND_TEST_STORE_EXIT;
    }
    else if(strcmp(cmd,"gcall") == 0)
    {
        printk("nand debug cmd:\n");
        printk("  gcall \n");
        mutex_lock(nand_kobj->nftl_blk->blk_lock);
        ret = gc_all(nand_kobj->nftl_blk->nftl_zone);
        mutex_unlock(nand_kobj->nftl_blk->blk_lock);
        goto NAND_TEST_STORE_EXIT;
    }
    else if(strcmp(cmd,"gcone") == 0)
    {
        printk("nand debug cmd:\n");
        printk("  gcone \n");
        mutex_lock(nand_kobj->nftl_blk->blk_lock);
        ret = gc_one(nand_kobj->nftl_blk->nftl_zone);
        mutex_unlock(nand_kobj->nftl_blk->blk_lock);
        goto NAND_TEST_STORE_EXIT;
    }
    else if(strcmp(cmd,"test") == 0)
    {
        printk("nand debug cmd:\n");
        printk("  test \n");
        mutex_lock(nand_kobj->nftl_blk->blk_lock);
        ret = nftl_set_zone_test((void*)nand_kobj->nftl_blk->nftl_zone,param0);
        mutex_unlock(nand_kobj->nftl_blk->blk_lock);
        goto NAND_TEST_STORE_EXIT;
    }
    else if(strcmp(cmd,"showall") == 0)
    {
        printk("nand debug cmd:\n");
        printk("  show all \n");
        print_free_list(nand_kobj->nftl_blk->nftl_zone);
        print_block_invalid_list(nand_kobj->nftl_blk->nftl_zone);
        print_nftl_zone(nand_kobj->nftl_blk->nftl_zone);
        goto NAND_TEST_STORE_EXIT;
    }
    else
    {
        printk("err, nand debug undefined cmd: %s\n", cmd);
    }

NAND_TEST_STORE_EXIT:
    return count;
}
Exemplo n.º 6
0
int main(int argc, char *argv[])
{
  int k, i, j, x, y; 
  int A[5][5];
  seq seq1 = {o, a, a, a, b, a};
  seq seq2 = {o, b, a, a, b, a};

  if(argc != 2 || (sscanf(argv[1], "%d", &k)) != 1) {
    printf("\tBitte Syntax beachten: ./afg41 <Substringlaenge>\n");
    exit(EXIT_FAILURE);
  }

  printf("\n");
  for(i = 1; i <= 6 - k; i++){
    for(j = 1; j <= 6 - k; j++){
      printf("\tmc(");
      for(x = k; x > 0; x--) {
	printf("%c", seq1[i+(k-x)]);
	if(x == 1) {
	  printf(", ");
	}
      }
      for(y = k; y > 0; y--) {
      printf("%c", seq2[j+(k-y)]);
	if(y == 1) {
	  printf(")\n");
	}
      }
    }
  }
  
  

  for(j = 0; j < 6; j++) {
    printf("\n");
    for(i = 0; i < 6; i++) {
      if((i == 0) || (j == 0)) {
	A[i][j] = 0;
      } else {
	A[i][j] = A[i-1][j-1];
	if(seq1[i] == seq2[j]) {
	  A[i][j] += 1;
	}
      }
      printf("\t%d", A[i][j]);
    }
  }
  printf("\n\n");
  for(i = 1; i <= 6 - k; i++){
    for(j = 1; j <= 6 - k; j++){
      printf("\tmc(");
      for(x = k; x > 0; x--) {
	printf("%c", seq1[i+(k-x)]);
	if(x == 1) {
	  printf(", ");
	}
      }
      for(y = k; y > 0; y--) {
      printf("%c", seq2[j+(k-y)]);
	if(y == 1) {
	  printf(") = %d\n", (A[i+(k-1)][j+(k-1)] - A[i-1][j-1]));
	}
      }
    }
  }
  printf("\n");
  return(EXIT_SUCCESS);
}
Exemplo n.º 7
0
void process_input(int* needs_refresh, const char *str, int fd, void (*cb)(int fd, const char *data, size_t len))
{
    static unsigned lcore_id, task_id, nb_packets, val, id,
           port, queue, rate, ip[4], prefix, next_hop_idx,
           interface, gre_id, svlan, cvlan, mac[6], user;
    unsigned count;
    float speed;
    uint32_t pkt_size;
    static char mode[20];
    struct rte_ring *ring;
    unsigned short offset;
    uint32_t value;
    uint8_t value_len;

    if (strcmp(str, "quit") == 0) {
        plog_info("Leaving...\n");
        stop_core_all();
        stop_dppd = 1;
    }
    else if (sscanf(str, "dump %u %u %u", &lcore_id, &task_id, &nb_packets) == 3) {
        if (lcore_id >= RTE_MAX_LCORE) {
            plog_err("Invalid core id %u (lcore ID above %d)\n", lcore_id, RTE_MAX_LCORE);
        }
        else if (!dppd_core_active(lcore_id, 0)) {
            plog_err("Invalid core id %u (lcore is not active)\n", lcore_id);
        }
        else {
            cmd_dump(lcore_id, task_id, nb_packets);
        }
    }
    else if (sscanf(str, "rate %u %u %u", &queue, &port, &rate) == 3) {
        if (port > DPPD_MAX_PORTS) {
            plog_err("Max port id allowed is %u (specified %u)\n", DPPD_MAX_PORTS, port);
        }
        else if (!dppd_port_cfg[port].active) {
            plog_err("Port %u not active\n", port);
        }
        else if (queue >= dppd_port_cfg[port].n_txq) {
            plog_err("Number of active queues is %u\n",
                     dppd_port_cfg[port].n_txq);
        }
        else if (rate > dppd_port_cfg[port].link_speed) {
            plog_err("Max rate allowed on port %u queue %u is %u Mbps\n",
                     port, queue, dppd_port_cfg[port].link_speed);
        }
        else {
            if (rate == 0) {
                plog_info("Disabling rate limiting on port %u queue %u\n",
                          port, queue);
            }
            else {
                plog_info("Setting rate limiting to %u Mbps on port %u queue %u\n",
                          rate, port, queue);
            }
            rte_eth_set_queue_rate_limit(port, queue, rate);
        }
    }
    else if (sscanf(str, "count %u %u %u", &lcore_id, &task_id, &count) == 3) {
        if (check_core_task(lcore_id, task_id)) {
            if (strcmp(lcore_cfg[lcore_id].targs[task_id].task_init->mode_str, "gen")) {
                plog_err("Core %u task %u is not generating packets\n", lcore_id, task_id);
            }
            else {
                ((struct task_gen *)lcore_cfg[lcore_id].task[task_id])->pkt_count = count;
                plog_info("Core %u task %u stopping after %u packets\n", lcore_id, task_id, count);
            }
        }
    }
    else if (sscanf(str, "pkt_size %u %u %d", &lcore_id, &task_id, &pkt_size) == 3) {
        if (check_core_task(lcore_id, task_id)) {
            if (strcmp(lcore_cfg[lcore_id].targs[task_id].task_init->mode_str, "gen")) {
                plog_err("Core %u task %u is not generating packets\n", lcore_id, task_id);
            }
            else if (pkt_size > 1514 || pkt_size < 34) {    // 34 for 14 + 20 (MAC, EtherType and IP)
                plog_err("pkt_size out of range (must be betweeen 34 and 1514)\n");
            }
            else {
                ((struct task_gen *)lcore_cfg[lcore_id].task[task_id])->pkt_size = pkt_size;
                plog_info("Setting pkt_size to %u \n", pkt_size);
            }
        }
    }

    else if (sscanf(str, "speed %u %u %f", &lcore_id, &task_id, &speed) == 3) {
        if (check_core_task(lcore_id, task_id)) {
            if (strcmp(lcore_cfg[lcore_id].targs[task_id].task_init->mode_str, "gen")) {
                plog_err("Core %u task %u is not generating packets\n", lcore_id, task_id);
            }
            else if (speed > 100.0f || speed < 0.0f) {
                plog_err("Speed out of range (must be betweeen 0%% and 100%%)\n");
            }
            else {
                uint64_t bps = speed * 12500000;

                ((struct task_gen *)lcore_cfg[lcore_id].task[task_id])->rate_bps = bps;
                plog_info("Setting rate to %"PRIu64" Bps\n", bps);
            }
        }
    }
    else if (sscanf(str, "speed_byte %u %u %u", &lcore_id, &task_id, &value) == 3) {
        if (check_core_task(lcore_id, task_id)) {
            if (strcmp(lcore_cfg[lcore_id].targs[task_id].task_init->mode_str, "gen")) {
                plog_err("Core %u task %u is not generating packets\n", lcore_id, task_id);
            }
            else if (value > 1250000000) {
                plog_err("Speed out of range (must be <= 1250000000)\n");
            }
            else {
                ((struct task_gen *)lcore_cfg[lcore_id].task[task_id])->rate_bps = value;
                plog_info("Setting rate to %"PRIu32" Bps\n", value);
            }
        }
    }
    else if (strcmp(str, "reset values all") == 0) {
        lcore_id = -1;
        while (dppd_core_next(&lcore_id, 0) == 0) {
            for (task_id = 0; task_id < lcore_cfg[lcore_id].nb_tasks; task_id++) {
                if (strcmp(lcore_cfg[lcore_id].targs[task_id].task_init->mode_str, "gen") == 0) {
                    struct task_gen *task = ((struct task_gen *)lcore_cfg[lcore_id].task[task_id]);
                    plog_info("Resetting values on core %d task %d from %d values\n", lcore_id, task_id, task->n_values);
                    task->n_values = 0;
                }
            }
        }
    }
    else if (sscanf(str, "reset values %u %u", &lcore_id, &task_id) == 2) {
        if (check_core_task(lcore_id, task_id)) {
            if (strcmp(lcore_cfg[lcore_id].targs[task_id].task_init->mode_str, "gen")) {
                plog_err("Core %u task %u is not generating packets\n", lcore_id, task_id);
            }
            else {
                struct task_gen *task = ((struct task_gen *)lcore_cfg[lcore_id].task[task_id]);
                plog_info("Resetting values on core %d task %d from %d values\n", lcore_id, task_id, task->n_values);
                task->n_values = 0;
            }
        }
    }
    else if (sscanf(str, "set value %u %u %hu %u %hhu", &lcore_id, &task_id, &offset, &value, &value_len) == 5) {
        if (check_core_task(lcore_id, task_id)) {
            if (strcmp(lcore_cfg[lcore_id].targs[task_id].task_init->mode_str, "gen")) {
                plog_err("Core %u task %u is not generating packets\n", lcore_id, task_id);
            }
            else if (offset > ETHER_MAX_LEN) {
                plog_err("Offset out of range (must be less then %u)\n", ETHER_MAX_LEN);
            }
            else if (value_len > 4) {
                plog_err("Length out of range (must be less then 4)\n");
            }
            else {
                struct task_gen *task = ((struct task_gen *)lcore_cfg[lcore_id].task[task_id]);
                if (task->n_values >= 64) {
                    plog_info("Unable to set Byte %"PRIu16" to %"PRIu8" - too many value set\n", offset, value);
                }
                else {
                    task->value[task->n_values] = rte_cpu_to_be_32(value) >> ((4 - value_len) * 8);
                    task->offset[task->n_values] = offset;
                    task->value_len[task->n_values] = value_len;
                    task->n_values++;
                    plog_info("Setting Byte %"PRIu16" to %"PRIu32"\n", offset, value);
                }
            }
        }
    }
    else if (sscanf(str, "thread info %u %u", &lcore_id, &task_id) == 2) {
Exemplo n.º 8
0
/** Get a value (object, clock, or global)
	\verbatim gl('get',name) \endverbatim
 **/
void cmex_get(int nlhs, mxArray *plhs[], /**< {data} */
				int nrhs, const mxArray *prhs[] ) /**< (name) */
{
	if (nrhs>0)
	{
		char name[1024];
		OBJECT *obj=NULL;
		if (!mxIsChar(prhs[0]))
			output_error("entity name (arg 1) is not a string");
		else if (nlhs>1)
			output_error("only one return value is possible");
		else if (mxGetString(prhs[0],name,sizeof(name))!=0)
			output_error("object name too long");
		else if (strcmp(name,"clock")==0)
		{
			char *fnames[] = {"timestamp","timestring","timezone"};
			char buffer[256];
			mxArray *pTimestamp = mxCreateDoubleMatrix(1,1,mxREAL);
			mxArray *pTimestring = mxCreateString(convert_from_timestamp(global_clock,buffer,sizeof(buffer))?buffer:"(error)");
			mxArray *pTimezone = mxCreateString(timestamp_current_timezone());

			*(double*)mxGetPr(pTimestamp) = ((double)global_clock)/TS_SECOND;
			plhs[0] = mxCreateStructMatrix(1,1,sizeof(fnames)/sizeof(fnames[0]),fnames);
			mxSetFieldByNumber(plhs[0],0,0,pTimestamp);
			mxSetFieldByNumber(plhs[0],0,1,pTimestring);
			mxSetFieldByNumber(plhs[0],0,2,pTimezone);
		}
		else if (strcmp(name,"property")==0 && nrhs>1)
		{
			if (mxGetString(prhs[1],name,sizeof(name))!=0)
				output_error("missing property name");
			else
			{
				char classname[256];
				char propname[256];
				if (sscanf(name,"%[^.].%s",classname,propname)==2)
				{
					CLASS *pClass = class_get_class_from_classname(classname);
					if (pClass)
					{
						PROPERTY *pProp = class_find_property(pClass,propname);
						if (pProp)
						{
							char *fields[] = {"class","name","type","size","access","unit","delegation","keywords"};
							int fn = 0;
							mxArray *oclass = mxCreateString(classname);
							mxArray *prop = mxCreateString(pProp->name);
							mxArray *type = mxCreateString(class_get_property_typename(pProp->ptype));
							mxArray *size = mxCreateDoubleMatrix(1,1,mxREAL); 
							mxArray *access = mxCreateString("(na)"); /** @todo implement get_property access info (ticket #187) */
							mxArray *unit = mxCreateString(pProp->unit->name);
							mxArray *delegation = mxCreateString(pProp->delegation?pProp->delegation->oclass->name:"(none)");
							mxArray *keywords = mxCreateString("(na)"); /** @todo implement get_property keywords (ticket #188) */
							*(mxGetPr(size)) = pProp->size==0?1:pProp->size;
							plhs[0] = mxCreateStructMatrix(1,1,sizeof(fields)/sizeof(fields[0]),fields);
							mxSetFieldByNumber(plhs[0],0,fn++,oclass);
							mxSetFieldByNumber(plhs[0],0,fn++,prop);
							mxSetFieldByNumber(plhs[0],0,fn++,type);
							mxSetFieldByNumber(plhs[0],0,fn++,size);
							mxSetFieldByNumber(plhs[0],0,fn++,access);
							mxSetFieldByNumber(plhs[0],0,fn++,unit);
							mxSetFieldByNumber(plhs[0],0,fn++,delegation);
							mxSetFieldByNumber(plhs[0],0,fn++,keywords);
						}
						else
							output_error("property %s is not found in class %s", propname,classname);
					}
					else
						output_error("class %s is not found");
				}
				else
					output_error("property name not in class.name format");
			}
		}
		else if ((convert_to_object(name,&obj,NULL))==0)
		{
			GLOBALVAR *var = global_find(name);
			if (var==NULL)
				output_error("entity '%s' not found", name);
			else if (var->prop->ptype==PT_double)
			{
				size_t size = var->prop->size?var->prop->size:1;
				plhs[0] = mxCreateDoubleMatrix(size,1,mxREAL);
				memcpy(mxGetPr(plhs[0]),(void*)var->prop->addr,sizeof(double)*size);
			}
			else if (var->prop->ptype==PT_int32)
			{
				size_t size = var->prop->size?var->prop->size:1;
				plhs[0] = mxCreateDoubleMatrix(size,1,mxREAL);

				memcpy(mxGetPr(plhs[0]),(void*)var->prop->addr,sizeof(double)*size);
			}
			else if (var->prop->ptype!=PT_double)
				output_error("cannot retrieve globals that are of type %s",class_get_property_typename(var->prop->ptype));
		}
		else if ((plhs[0]=get_object_data(obj))==NULL)
			output_error("unable to extract %s data", name);
	}
	else
		output_error("object not specified");
	return;
}
Exemplo n.º 9
0
int adb_main(int is_daemon, int server_port)
{
#if !ADB_HOST
    int port;
    char value[PROPERTY_VALUE_MAX];

    umask(000);
#endif

    atexit(adb_cleanup);
#ifdef HAVE_WIN32_PROC
    SetConsoleCtrlHandler( ctrlc_handler, TRUE );
#elif defined(HAVE_FORKEXEC)
    // No SIGCHLD. Let the service subproc handle its children.
    signal(SIGPIPE, SIG_IGN);
#endif

    init_transport_registration();

#if ADB_HOST
    HOST = 1;

#ifdef WORKAROUND_BUG6558362
    if(is_daemon) adb_set_affinity();
#endif
    usb_vendors_init();
    usb_init();
    local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT);
    adb_auth_init();

    char local_name[30];
    build_local_name(local_name, sizeof(local_name), server_port);
    if(install_listener(local_name, "*smartsocket*", NULL, 0)) {
        exit(1);
    }
#else
    property_get("ro.adb.secure", value, "0");
    auth_enabled = !strcmp(value, "1");
    if (auth_enabled)
        adb_auth_init();

    // Our external storage path may be different than apps, since
    // we aren't able to bind mount after dropping root.
    const char* adb_external_storage = getenv("ADB_EXTERNAL_STORAGE");
    if (NULL != adb_external_storage) {
        setenv("EXTERNAL_STORAGE", adb_external_storage, 1);
    } else {
        D("Warning: ADB_EXTERNAL_STORAGE is not set.  Leaving EXTERNAL_STORAGE"
          " unchanged.\n");
    }

    /* don't listen on a port (default 5037) if running in secure mode */
    /* don't run as root if we are running in secure mode */
    if (should_drop_privileges()) {
        drop_capabilities_bounding_set_if_needed();

        /* add extra groups:
        ** AID_ADB to access the USB driver
        ** AID_LOG to read system logs (adb logcat)
        ** AID_INPUT to diagnose input issues (getevent)
        ** AID_INET to diagnose network issues (netcfg, ping)
        ** AID_GRAPHICS to access the frame buffer
        ** AID_NET_BT and AID_NET_BT_ADMIN to diagnose bluetooth (hcidump)
        ** AID_SDCARD_R to allow reading from the SD card
        ** AID_SDCARD_RW to allow writing to the SD card
        ** AID_NET_BW_STATS to read out qtaguid statistics
        */
        gid_t groups[] = { AID_ADB, AID_LOG, AID_INPUT, AID_INET, AID_GRAPHICS,
                           AID_NET_BT, AID_NET_BT_ADMIN, AID_SDCARD_R, AID_SDCARD_RW,
                           AID_NET_BW_STATS };
        if (setgroups(sizeof(groups)/sizeof(groups[0]), groups) != 0) {
            exit(1);
        }

        /* then switch user and group to "shell" */
        if (setgid(AID_SHELL) != 0) {
            exit(1);
        }
        if (setuid(AID_SHELL) != 0) {
            exit(1);
        }

        D("Local port disabled\n");
    } else {
        char local_name[30];
        build_local_name(local_name, sizeof(local_name), server_port);
        if(install_listener(local_name, "*smartsocket*", NULL, 0)) {
            exit(1);
        }
    }

    int usb = 0;
    if (access(USB_ADB_PATH, F_OK) == 0 || access(USB_FFS_ADB_EP0, F_OK) == 0) {
        // listen on USB
        usb_init();
        usb = 1;
    }

    // If one of these properties is set, also listen on that port
    // If one of the properties isn't set and we couldn't listen on usb,
    // listen on the default port.
    property_get("service.adb.tcp.port", value, "");
    if (!value[0]) {
        property_get("persist.adb.tcp.port", value, "");
    }
    if (sscanf(value, "%d", &port) == 1 && port > 0) {
        printf("using port=%d\n", port);
        // listen on TCP port specified by service.adb.tcp.port property
        local_init(port);
    } else if (!usb) {
        // listen on default port
        local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT);
    }

    D("adb_main(): pre init_jdwp()\n");
    init_jdwp();
    D("adb_main(): post init_jdwp()\n");
#endif

    if (is_daemon)
    {
        // inform our parent that we are up and running.
#ifdef HAVE_WIN32_PROC
        DWORD  count;
        WriteFile( GetStdHandle( STD_OUTPUT_HANDLE ), "OK\n", 3, &count, NULL );
#elif defined(HAVE_FORKEXEC)
        fprintf(stderr, "OK\n");
#endif
        start_logging();
    }
    D("Event loop starting\n");

    fdevent_loop();

    usb_cleanup();

    return 0;
}
Exemplo n.º 10
0
// FOR SYNCED MESSAGES
void CGame::ActionReceived(const Action& action, int playernum)
{
	if (action.command == "cheat") {
		SetBoolArg(gs->cheatEnabled, action.extra);
		if (gs->cheatEnabled)
			logOutput.Print("Cheating!");
		else
			logOutput.Print("No more cheating");
	}
	else if (action.command == "nohelp") {
		SetBoolArg(gs->noHelperAIs, action.extra);
		selectedUnits.PossibleCommandChange(NULL);
		logOutput.Print("LuaUI control is %s", gs->noHelperAIs ? "disabled" : "enabled");
	}
	else if (action.command == "nospecdraw") {
		bool buf;
		SetBoolArg(buf, action.extra);
		inMapDrawer->SetSpecMapDrawingAllowed(buf);
	}
	else if (action.command == "godmode") {
		if (!gs->cheatEnabled)
			logOutput.Print("godmode requires /cheat");
		else {
			SetBoolArg(gs->godMode, action.extra);
			CLuaUI::UpdateTeams();
			if (gs->godMode) {
				logOutput.Print("God Mode Enabled");
			} else {
				logOutput.Print("God Mode Disabled");
			}
			CPlayer::UpdateControlledTeams();
		}
	}
	else if (action.command == "globallos") {
		if (!gs->cheatEnabled) {
			logOutput.Print("globallos requires /cheat");
		} else {
			SetBoolArg(gs->globalLOS, action.extra);
			if (gs->globalLOS) {
				logOutput.Print("Global LOS Enabled");
			} else {
				logOutput.Print("Global LOS Disabled");
			}
		}
	}
	else if (action.command == "nocost" && gs->cheatEnabled) {
		if (unitDefHandler->ToggleNoCost()) {
			logOutput.Print("Everything is for free!");
		} else {
			logOutput.Print("Everything costs resources again!");
		}
	}
	else if (action.command == "give" && gs->cheatEnabled) {
		std::string s = "give "; //FIXME lazyness
		s += action.extra;

		// .give [amount] <unitName> [team] <@x,y,z>
		const vector<string> &args = CSimpleParser::Tokenize(s, 0);

		if (args.size() < 3) {
			logOutput.Print("Someone is spoofing invalid .give messages!");
			return;
		}

		float3 pos;
		if (sscanf(args[args.size() - 1].c_str(), "@%f,%f,%f", &pos.x, &pos.y, &pos.z) != 3) {
			logOutput.Print("Someone is spoofing invalid .give messages!");
			return;
		}

		int amount = 1;
		int team = playerHandler->Player(playernum)->team;
		int allyteam = -1;

		int amountArgIdx = -1;
		int teamArgIdx = -1;

		if (args.size() == 5) {
			amountArgIdx = 1;
			teamArgIdx = 3;
		}
		else if (args.size() == 4) {
			if (args[1].find_first_not_of("0123456789") == string::npos) {
				amountArgIdx = 1;
			} else {
				teamArgIdx = 2;
			}
		}

		if (amountArgIdx >= 0) {
			const string& amountStr = args[amountArgIdx];
			amount = atoi(amountStr.c_str());
			if ((amount < 0) || (amountStr.find_first_not_of("0123456789") != string::npos)) {
				logOutput.Print("Bad give amount: %s", amountStr.c_str());
				return;
			}
		}

		if (teamArgIdx >= 0) {
			const string& teamStr = args[teamArgIdx];
			team = atoi(teamStr.c_str());
			if ((team < 0) || (team >= teamHandler->ActiveTeams()) || (teamStr.find_first_not_of("0123456789") != string::npos)) {
				logOutput.Print("Bad give team: %s", teamStr.c_str());
				return;
			}
		}

		const string unitName = (amountArgIdx >= 0) ? args[2] : args[1];

		if (unitName == "all") {
			// player entered ".give all"
			int numRequestedUnits = unitDefHandler->unitDefs.size() - 1; /// defid=0 is not valid
			int currentNumUnits = teamHandler->Team(team)->units.size();
			int sqSize = (int) streflop::ceil(streflop::sqrt((float) numRequestedUnits));

			// make sure team unit-limit not exceeded
			if ((currentNumUnits + numRequestedUnits) > uh->MaxUnitsPerTeam()) {
				numRequestedUnits = uh->MaxUnitsPerTeam() - currentNumUnits;
			}

			// make sure square is entirely on the map
			float sqHalfMapSize = sqSize / 2 * 10 * SQUARE_SIZE;
			pos.x = std::max(sqHalfMapSize, std::min(pos.x, float3::maxxpos - sqHalfMapSize - 1));
			pos.z = std::max(sqHalfMapSize, std::min(pos.z, float3::maxzpos - sqHalfMapSize - 1));

			for (int a = 1; a <= numRequestedUnits; ++a) {
				float posx = pos.x + (a % sqSize - sqSize / 2) * 10 * SQUARE_SIZE;
				float posz = pos.z + (a / sqSize - sqSize / 2) * 10 * SQUARE_SIZE;
				float3 pos2 = float3(posx, pos.y, posz);
				const UnitDef* ud = unitDefHandler->GetUnitDefByID(a);
				if (ud) {
					const CUnit* unit = unitLoader.LoadUnit(ud, pos2, team, false, 0, NULL);
					if (unit) {
						unitLoader.FlattenGround(unit);
					}
				}
			}
		}
		else if (!unitName.empty()) {
			int numRequestedUnits = amount;
			int currentNumUnits = teamHandler->Team(team)->units.size();

			if (currentNumUnits >= uh->MaxUnitsPerTeam()) {
				LogObject() << "Unable to give any more units to team " << team << "(current: " << currentNumUnits << ", max: " << uh->MaxUnits() << ")";
				return;
			}

			// make sure team unit-limit is not exceeded
			if ((currentNumUnits + numRequestedUnits) > uh->MaxUnitsPerTeam()) {
				numRequestedUnits = uh->MaxUnitsPerTeam() - currentNumUnits;
			}

			const UnitDef* unitDef = unitDefHandler->GetUnitDefByName(unitName);

			if (unitDef != NULL) {
				int xsize = unitDef->xsize;
				int zsize = unitDef->zsize;
				int squareSize = (int) streflop::ceil(streflop::sqrt((float) numRequestedUnits));
				int total = numRequestedUnits;

				float3 minpos = pos;
				minpos.x -= ((squareSize - 1) * xsize * SQUARE_SIZE) / 2;
				minpos.z -= ((squareSize - 1) * zsize * SQUARE_SIZE) / 2;

				for (int z = 0; z < squareSize; ++z) {
					for (int x = 0; x < squareSize && total > 0; ++x) {
						float minposx = minpos.x + x * xsize * SQUARE_SIZE;
						float minposz = minpos.z + z * zsize * SQUARE_SIZE;
						const float3 upos(minposx, minpos.y, minposz);
						const CUnit* unit = unitLoader.LoadUnit(unitDef, upos, team, false, 0, NULL);

						if (unit) {
							unitLoader.FlattenGround(unit);
						}
						--total;
					}
				}

				logOutput.Print("Giving %i %s to team %i", numRequestedUnits, unitName.c_str(), team);
			} else {
				if (teamArgIdx < 0) {
					team = -1; // default to world features
					allyteam = -1;
				} else {
					allyteam = teamHandler->AllyTeam(team);
				}

				const FeatureDef* featureDef = featureHandler->GetFeatureDef(unitName);
				if (featureDef) {
					int xsize = featureDef->xsize;
					int zsize = featureDef->zsize;
					int squareSize = (int) streflop::ceil(streflop::sqrt((float) numRequestedUnits));
					int total = amount; // FIXME -- feature count limit?

					float3 minpos = pos;
					minpos.x -= ((squareSize - 1) * xsize * SQUARE_SIZE) / 2;
					minpos.z -= ((squareSize - 1) * zsize * SQUARE_SIZE) / 2;

					for (int z = 0; z < squareSize; ++z) {
						for (int x = 0; x < squareSize && total > 0; ++x) {
							float minposx = minpos.x + x * xsize * SQUARE_SIZE;
							float minposz = minpos.z + z * zsize * SQUARE_SIZE;
							float minposy = ground->GetHeight2(minposx, minposz);
							const float3 upos(minposx, minposy, minposz);

							CFeature* feature = new CFeature();
							feature->Initialize(upos, featureDef, 0, 0, team, allyteam, "");
							--total;
						}
					}

					logOutput.Print("Giving %i %s (feature) to team %i",
									numRequestedUnits, unitName.c_str(), team);
				}
				else {
					logOutput.Print(unitName + " is not a valid unitname");
				}
			}
		}
	}
	else if (action.command == "destroy" && gs->cheatEnabled) {
		std::stringstream ss(action.extra);
		logOutput.Print("Killing units: %s", action.extra.c_str());
		do {
			unsigned id;
			ss >> id;
			if (!ss)
				break;
			if (id >= uh->units.size())
				continue;
			if (uh->units[id] == NULL)
				continue;
			uh->units[id]->KillUnit(false, false, 0);
		} while (true);
	}
Exemplo n.º 11
0
void http_do_requests(GF_DownloadSession *sess)
{
	GF_Err e;
	Bool is_ice;
	GF_NETIO_Parameter par;
	char sHTTP[GF_DOWNLOAD_BUFFER_SIZE];
	char buf[1024];
	char comp[400];
	char *new_location;
	char *hdr, *hdr_val;
	u32 bytesRead, res;
	s32 LinePos, Pos;
	u32 rsp_code, ContentLength, first_byte, last_byte, total_size, range, no_range;
	s32 BodyStart;

	/*sent HTTP request*/
	if (sess->status==GF_NETIO_CONNECTED) {
		char range_buf[1024];
		char pass_buf[1024];
		const char *user_agent;
		u32 size;
		Bool has_accept, has_connection, has_range, has_agent;

		/*setup authentification*/
		strcpy(pass_buf, "");
		if (sess->user) {
			if (!sess->passwd) {
				char szUSR[50], szPASS[50];
				strcpy(szUSR, sess->user);
				strcpy(szPASS, "");
				/*failed getting pass*/
				if (!sess->dm->GetUserPassword || !sess->dm->GetUserPassword(sess->dm->usr_cbk, sess->server_name, szUSR, szPASS)) {
					sess->status = GF_NETIO_STATE_ERROR;
					return;
				}
				sess->passwd = strdup(szPASS);
			}
			sprintf(pass_buf, "%s:%s", sess->user, sess->passwd);
			size = gf_base64_encode(pass_buf, strlen(pass_buf), range_buf, 1024);
			range_buf[size] = 0;
			sprintf(pass_buf, "Authorization: Basic %s", range_buf);
		}


		/*MIX2005 KMS project*/
#if 0
		if (strstr(sess->remote_path, "getKey.php?")) {
			char *sLogin, *sPass;
			sLogin = gf_cfg_get_key(sess->dm->cfg, "General", "KMS_User");
			sPass = gf_cfg_get_key(sess->dm->cfg, "General", "KMS_Password");
			if (!sLogin) sLogin = "******";
			if (!sPass) sPass = "******";
			sprintf(https_get_buffer, "%s&login=%s&password=%s", sess->remote_path, sLogin, sPass);
		}
#endif	

		user_agent = gf_cfg_get_key(sess->dm->cfg, "Downloader", "UserAgent");
		if (!user_agent) user_agent = GF_DOWNLOAD_AGENT_NAME;

		par.error = 0;
		par.msg_type = GF_NETIO_GET_METHOD;
		par.name = NULL;
		gf_dm_sess_user_io(sess, &par);

		if (par.name) {
			if (!strcmp(par.name, "GET")) sess->http_read_type = 0;
			else if (!strcmp(par.name, "HEAD")) sess->http_read_type = 1;
			else sess->http_read_type = 2;
		} else {
			sess->http_read_type = 0;
		}

		sprintf(sHTTP, "%s %s HTTP/1.0\r\nHost: %s\r\n" ,
			par.name ? par.name : "GET", sess->remote_path, sess->server_name);

		/*signal we support title streaming*/
		if (!strcmp(sess->remote_path, "/")) strcat(sHTTP, "icy-metadata:1\r\n");

		/*get all headers*/
		has_agent = has_accept = has_connection = has_range = 0;
		while (1) {
			par.msg_type = GF_NETIO_GET_HEADER;
			par.name = NULL;
			par.value = NULL;
			gf_dm_sess_user_io(sess, &par);
			if (!par.name) break;
			strcat(sHTTP, par.name);
			strcat(sHTTP, ": ");
			strcat(sHTTP, par.value);
			strcat(sHTTP, "\r\n");
			if (!strcmp(par.name, "Accept")) has_accept = 1;
			else if (!strcmp(par.name, "Connection")) has_connection = 1;
			else if (!strcmp(par.name, "Range")) has_range = 1;
			else if (!strcmp(par.name, "User-Agent")) has_agent = 1;
		}
		if (!has_agent) {
			strcat(sHTTP, "User-Agent: ");
			strcat(sHTTP, user_agent);
			strcat(sHTTP, "\r\n");
		}
		if (!has_accept) strcat(sHTTP, "Accept: */*\r\n");
		if (!has_connection) strcat(sHTTP, "Connection: Keep-Alive\r\n");
		if (!has_range && sess->cache_start_size) {
			sprintf(range_buf, "Range: bytes=%d-\r\n", sess->cache_start_size);
			strcat(sHTTP, range_buf);
		}
		if (strlen(pass_buf)) {
			strcat(sHTTP, pass_buf);
			strcat(sHTTP, "\r\n");
		}
		if (sess->flags & GF_DOWNLOAD_IS_ICY) strcat(sHTTP, "Icy-Metadata: 1\r\n");
		
		par.msg_type = GF_NETIO_GET_CONTENT;
		par.data = NULL;
		par.size = 0;
		gf_dm_sess_user_io(sess, &par);
		if (par.data && par.size) {
			sprintf(range_buf, "Content-Length: %d\r\n", par.size);
			strcat(sHTTP, range_buf);
		}
		strcat(sHTTP, "\r\n");

#ifdef GPAC_HAS_SSL
		if (sess->ssl) {
			e = GF_IP_NETWORK_FAILURE;
			if (!SSL_write(sess->ssl, sHTTP, strlen(sHTTP))) e = GF_OK;
		} else 
#endif
			e = gf_sk_send(sess->sock, sHTTP, strlen(sHTTP));

		GF_LOG(GF_LOG_DEBUG, GF_LOG_NETWORK, ("[HTTP] %s\n\n", sHTTP));
		if (e) {
			sess->status = GF_NETIO_STATE_ERROR;
			sess->last_error = e;
			gf_dm_sess_notify_state(sess, GF_NETIO_STATE_ERROR, e);
			return;
		}

		if (par.size && par.data) {
			u32 done = 0;
			while (done<par.size) {
			
#ifdef GPAC_HAS_SSL
				if (sess->ssl) {
					e = GF_IP_NETWORK_FAILURE;
					if (!SSL_write(sess->ssl, par.data+done, par.size-done)) e = GF_OK;
				} else 
#endif
					e = gf_sk_send(sess->sock, par.data+done, par.size-done);

				if (e) {
					sess->status = GF_NETIO_STATE_ERROR;
					sess->last_error = e;
					gf_dm_sess_notify_state(sess, GF_NETIO_STATE_ERROR, e);
					return;
				}
			}
		}
		sess->status = GF_NETIO_WAIT_FOR_REPLY;
		gf_dm_sess_notify_state(sess, GF_NETIO_WAIT_FOR_REPLY, GF_OK);
		return;
	}

	/*process HTTP request*/
	if (sess->status == GF_NETIO_WAIT_FOR_REPLY) {
		bytesRead = res = 0;
		new_location = NULL;
		while (1) {
			e = gf_dm_read_data(sess, sHTTP + bytesRead, GF_DOWNLOAD_BUFFER_SIZE - bytesRead, &res);
	
			switch (e) {
			case GF_IP_NETWORK_EMPTY:
				if (!bytesRead) return;
				continue;
			/*socket has been closed while configuring, retry (not sure if the server got the GET)*/
			case GF_IP_CONNECTION_CLOSED:
				gf_dm_disconnect(sess);
				if (sess->num_retry)
					sess->status = GF_NETIO_SETUP;
				else {
					sess->last_error = e;
					sess->status = GF_NETIO_STATE_ERROR;
				}
				return;
			case GF_OK:
				if (!res) return;
				break;
			default:
				goto exit;
			}
			bytesRead += res;

			/*locate body start*/
			BodyStart = gf_token_find(sHTTP, 0, bytesRead, "\r\n\r\n");
			if (BodyStart <= 0) {
				BodyStart=0;
				continue;
			}
			BodyStart += 4;
			break;
		}
		if (bytesRead < 0) {
			e = GF_REMOTE_SERVICE_ERROR;
			goto exit;
		}
		if (!BodyStart) 
			BodyStart = bytesRead;

		sHTTP[BodyStart-1] = 0;
		GF_LOG(GF_LOG_DEBUG, GF_LOG_NETWORK, ("[HTTP] %s\n\n", sHTTP));

		LinePos = gf_token_get_line(sHTTP, 0, bytesRead, buf, 1024);
		Pos = gf_token_get(buf, 0, " \t\r\n", comp, 400);

		if (sess->mime_type) free(sess->mime_type);
		sess->mime_type = NULL;

		is_ice = 0;
		if (!strncmp("ICY", comp, 4)) {
			is_ice = 1;
			/*be prepared not to recieve any mime type from ShoutCast servers*/
			sess->mime_type = strdup("audio/mpeg");
		} else if ((strncmp("HTTP", comp, 4) != 0)) {
			e = GF_REMOTE_SERVICE_ERROR;
			goto exit;
		}
		Pos = gf_token_get(buf, Pos, " ", comp, 400);
		if (Pos <= 0) {
			e = GF_REMOTE_SERVICE_ERROR;
			goto exit;
		}
		rsp_code = (u32) atoi(comp);
		Pos = gf_token_get(buf, Pos, " \r\n", comp, 400);

		no_range = range = ContentLength = first_byte = last_byte = total_size = 0;
		//parse header
		while (1) {
			char *sep, *hdr_sep;
			if ( (u32) LinePos + 4 > BodyStart) break;
			LinePos = gf_token_get_line(sHTTP, LinePos , bytesRead, buf, 1024);
			if (LinePos < 0) break;

			hdr_sep = NULL;
			hdr_val = NULL;
			hdr = buf;
			sep = strchr(buf, ':');
			if (sep) {
				sep[0]=0;
				hdr_val = sep+1;
				while (hdr_val[0]==' ') hdr_val++;
				hdr_sep = strrchr(hdr_val, '\r');
				if (hdr_sep) hdr_sep[0] = 0;
			}

			par.error = 0;
			par.msg_type = GF_NETIO_PARSE_HEADER;
			par.name = hdr;
			par.value = hdr_val;
			gf_dm_sess_user_io(sess, &par);

			if (!stricmp(hdr, "Content-Length") ) ContentLength = (u32) atoi(hdr_val);
			else if (!stricmp(hdr, "Content-Type")) {			
				if (sess->mime_type) free(sess->mime_type);
				sess->mime_type = strdup(hdr_val);
				while (1) {
					u32 len = strlen(sess->mime_type);
					char c = len ? sess->mime_type[len-1] : 0;
					if ((c=='\r') || (c=='\n')) {
						sess->mime_type[len-1] = 0;
					} else {
						break;
					}
				}
				hdr = strchr(sess->mime_type, ';');
				if (hdr) hdr[0] = 0;
			}
			else if (!stricmp(hdr, "Content-Range")) {			
				range = 1;
				if (!strncmp(hdr_val, "bytes", 5)) {
					hdr_val += 5;
					if (hdr_val[0] == ':') hdr_val += 1;
					hdr_val += http_skip_space(hdr_val);
					if (hdr_val[0] == '*') {
						sscanf(hdr_val, "*/%d", &total_size);
					} else {
						sscanf(hdr_val, "%d-%d/%d", &first_byte, &last_byte, &total_size);
					}
				}
			}
			else if (!stricmp(hdr, "Accept-Ranges")) {
				if (strstr(hdr_val, "none")) no_range = 1;
			}
			else if (!stricmp(hdr, "Location")) 
				new_location = strdup(hdr_val);
			else if (!stricmp(hdr, "icy-metaint")) 
				sess->icy_metaint = atoi(hdr_val);
			else if (!stricmp(hdr, "ice") || !stricmp(hdr, "icy") ) 
				is_ice = 1;

			if (sep) sep[0]=':';
			if (hdr_sep) hdr_sep[0] = '\r';
		}
		if (no_range) first_byte = 0;

		if (sess->cache_start_size) {
			if (total_size && (sess->cache_start_size >= total_size) ) {
				rsp_code = 200;
				ContentLength = total_size;
			}
			if (ContentLength && (sess->cache_start_size == ContentLength) ) rsp_code = 200;
		}	

		par.msg_type = GF_NETIO_PARSE_REPLY;
		par.error = GF_OK;
		par.reply = rsp_code;
		par.value = comp;

		switch (rsp_code) {
		case 200:
		case 201:
		case 202:
		case 206:
			gf_dm_sess_user_io(sess, &par);
			e = GF_OK;
			break;
		/*redirection: extract the new location*/
		case 301:
		case 302:
			if (!new_location || !strlen(new_location) ) {
				gf_dm_sess_user_io(sess, &par);
				e = GF_URL_ERROR;
				goto exit;
			}
			while (
				(new_location[strlen(new_location)-1] == '\n') 
				|| (new_location[strlen(new_location)-1] == '\r')  )
				new_location[strlen(new_location)-1] = 0;

			/*reset and reconnect*/
			gf_dm_disconnect(sess);
			sess->status = GF_NETIO_SETUP;
			e = gf_dm_setup_from_url(sess, new_location);
			if (e) {
				sess->status = GF_NETIO_STATE_ERROR;
				sess->last_error = e;
				gf_dm_sess_notify_state(sess, sess->status, e);
				return;
			}
			return;
		case 404:
		case 416:
			/*try without cache (some servers screw up when content-length is specified)*/
			if (sess->cache_start_size) {
				gf_dm_disconnect(sess);
				sess->status = GF_NETIO_SETUP;
				return;
			} else if (is_ice && !(sess->flags & GF_DOWNLOAD_IS_ICY)) {
				gf_dm_disconnect(sess);
				sess->status = GF_NETIO_SETUP;
				sess->flags |= GF_DOWNLOAD_IS_ICY;
				return;
			}
			gf_dm_sess_user_io(sess, &par);
			e = GF_URL_ERROR;
			goto exit;
		case 503:
		default:
			gf_dm_sess_user_io(sess, &par);
			e = GF_REMOTE_SERVICE_ERROR;
			goto exit;
		}

		/*head*/
		if (sess->http_read_type==1) {
			gf_dm_disconnect(sess);
			gf_dm_sess_notify_state(sess, GF_NETIO_DATA_TRANSFERED, GF_OK);
			sess->status = GF_NETIO_DISCONNECTED;
			sess->http_read_type = 0;
			return;
		}

		if (!ContentLength && sess->mime_type && strstr(sess->mime_type, "ogg")) is_ice = 1;

		/*some servers may reply without content length, but we MUST have it*/
//		if (!is_ice && !ContentLength) e = GF_REMOTE_SERVICE_ERROR;
		if (e) goto exit;

		/*force disabling cache (no content length)*/
		if (is_ice) {
			sess->flags |= GF_NETIO_SESSION_NOT_CACHED;
			if (sess->mime_type && !stricmp(sess->mime_type, "video/nsv")) {
				free(sess->mime_type);
				sess->mime_type = strdup("audio/aac");
			}
		}


		/*done*/
		if (sess->cache_start_size 
			&& ( (total_size && sess->cache_start_size >= total_size) || (sess->cache_start_size == ContentLength)) ) {
			sess->total_size = sess->bytes_done = sess->cache_start_size;
			/*disconnect*/
			gf_dm_disconnect(sess);
			BodyStart = bytesRead;
			gf_dm_sess_notify_state(sess, GF_NETIO_DATA_TRANSFERED, GF_OK);
		}
		else if (sess->flags & GF_DOWNLOAD_IS_ICY) {
			sess->icy_bytes = 0;
			sess->status = GF_NETIO_DATA_EXCHANGE;
		}
		/*we don't expect anything*/
		else if (!ContentLength && sess->http_read_type) {
			gf_dm_disconnect(sess);
			gf_dm_sess_notify_state(sess, GF_NETIO_DATA_TRANSFERED, GF_OK);
			sess->status = GF_NETIO_DISCONNECTED;
			sess->http_read_type = 0;
		}
		/*no range header, Accep-Ranges deny or dumb server : restart*/
		else if (!range || !first_byte || (first_byte != sess->cache_start_size) ) {
			sess->cache_start_size = sess->bytes_done = 0;
			sess->total_size = ContentLength;
			if (! (sess->flags & GF_NETIO_SESSION_NOT_CACHED) ) {
				sess->cache = fopen(sess->cache_name, "wb");
				if (!sess->cache) {
					e = GF_IO_ERR;
					goto exit;
				}
			}
			sess->status = GF_NETIO_DATA_EXCHANGE;
		}
		/*resume*/
		else {
			sess->total_size = ContentLength + sess->cache_start_size;
			if (! (sess->flags & GF_NETIO_SESSION_NOT_CACHED) ) {
				sess->cache = fopen(sess->cache_name, "ab");
				if (!sess->cache) {
					e = GF_IO_ERR;
					goto exit;
				}
			}
			sess->status = GF_NETIO_DATA_EXCHANGE;
			sess->bytes_done = sess->cache_start_size;
		}

		sess->window_start = sess->start_time = gf_sys_clock();
		sess->bytes_in_wnd = 0;


		//we may have existing data in this buffer ...
		if (!e && (BodyStart < (u32) bytesRead)) {
			gf_dm_data_recieved(sess, sHTTP + BodyStart, bytesRead - BodyStart);
			/*store data if no callbacks or cache*/
			if (sess->flags & GF_NETIO_SESSION_NOT_CACHED) {
				if (sess->init_data) free(sess->init_data);
				sess->init_data_size = bytesRead - BodyStart;
				sess->init_data = (char *) malloc(sizeof(char) * sess->init_data_size);
				memcpy(sess->init_data, sHTTP+BodyStart, sess->init_data_size);
			}
		}
exit:
		if (e) {
			gf_dm_disconnect(sess);
			sess->status = GF_NETIO_STATE_ERROR;
			sess->last_error = e;
			gf_dm_sess_notify_state(sess, sess->status, e);
		}
		return;
	}
	/*fetch data*/
	while (1) {
		u32 size;
#if 1
		if (sess->limit_data_rate && sess->bytes_per_sec) {
			if (sess->bytes_per_sec>sess->limit_data_rate) {
				/*update state*/
				u32 runtime = gf_sys_clock() - sess->window_start;
				sess->bytes_per_sec = (1000 * (sess->bytes_in_wnd)) / runtime;
				if (sess->bytes_per_sec > sess->limit_data_rate) return;
			}
		}
#endif
		e = gf_dm_read_data(sess, sHTTP, GF_DOWNLOAD_BUFFER_SIZE, &size);
		if (!size || e == GF_IP_NETWORK_EMPTY) {
		
			if (!sess->total_size && (gf_sys_clock() - sess->window_start > 1000)) {
				sess->total_size = sess->bytes_done;
				gf_dm_sess_notify_state(sess, GF_NETIO_DATA_TRANSFERED, GF_OK);
			}
			return;
		}

		if (e) {
			gf_dm_disconnect(sess);
			sess->last_error = e;
			gf_dm_sess_notify_state(sess, sess->status, e);
			return;
		}
		gf_dm_data_recieved(sess, sHTTP, size);
		/*socket empty*/
		if (size < GF_DOWNLOAD_BUFFER_SIZE) return;
	}
}
Exemplo n.º 12
0
int main(int argc, char **argv)
{
	/* The following things are used for getopt: */
	extern char *optarg;
	extern int optind;
	extern int opterr;
	int ch;

        in_addr_t dest;
        struct sockaddr_in destaddr,fromaddr,servaddr;
        socklen_t fromlen;
        int sockfd_r;
        struct hostent *hp;
        char *buf;
        char dest_str[16];
#define RBLEN 500
        char recbuf[RBLEN+1];
        ssize_t recmegslen;


        fromlen = sizeof(fromaddr); // this is important otherwise recvfrom will return "Invalid argument"
	opterr = 0;
	while ((ch = getopt(argc, argv, "hp:")) != -1) {
		switch (ch) {
			case 'p':
				sscanf(optarg,"%d",&portnum);
				break;
			case 'h':
				help();
			case '?':
				fprintf(stderr, "ERROR: No such option. -h for help.\n");
				exit(1);
			/*no default action for case */
			}
	}
	if (optind != argc -2){
		/* exactly two arguments must be given */
		help();
	}
        if (strlen(argv[optind])>45){
                fprintf(stderr,"Error: command too long. Max is 45\n");
                exit(1);
        }
        buf=argv[optind];
        //
        hp=gethostbyname(argv[optind+1]);
        if (hp==NULL){
                fprintf(stderr,"Error: %s is not a IP address and not a resolvable hostname\n",argv[optind+1]);
                exit(1);
        }
        // take the first address:
        strncpy(dest_str,inet_ntoa(*(struct in_addr*)hp->h_addr_list[0]),sizeof(dest_str));
        dest_str[sizeof(dest_str)-1]='\0';
        dest=inet_addr(dest_str);
        if (dest==INADDR_NONE){
                fprintf(stderr,"Error: IP addr. not valid\n");
                exit(1);
        }
        //
        printf("II: data: %s, ip: %s port: %d\n",argv[optind],dest_str,portnum);
        /* initialize the socket address for the destination: */
        destaddr.sin_family = AF_INET;
        destaddr.sin_addr.s_addr = dest;
        destaddr.sin_port = htons(portnum); // dest port
        /* initialize the socket address for this server: */
        servaddr.sin_family = AF_INET;
        servaddr.sin_addr.s_addr = htonl(INADDR_ANY); 
        servaddr.sin_port = htons(portnum); // source port
	memset(&servaddr.sin_zero, 0, sizeof(servaddr.sin_zero)); // zero fill

        if ((sockfd_r = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
        {
                perror("open socket failed");
                exit(1);
        }
        if (bind(sockfd_r, (struct sockaddr *)&servaddr, sizeof(servaddr))){
                perror("bind socket failed");
                exit(1);
        }
        // we are bound. The parent will get the message even if the sender
	// sends it before we call recvfrom
	/* the closing \0 will be sent as well: */
	if(sendto(sockfd_r,buf,strlen(buf)+1,0,(struct sockaddr *)&destaddr,sizeof(destaddr)) == -1){
		perror("sendto failed");
		exit(1);
	}
        // we will timeout if there is no answer after a few sec
        signal(SIGALRM, &timeout_handler);
        alarm(3);
        recmegslen=recvfrom(sockfd_r,recbuf,RBLEN-1,0,(struct sockaddr *)&fromaddr,&fromlen);
        if(recmegslen == -1){
                perror("recvfrom failed");
                exit(1);
        }
        close(sockfd_r);
        recbuf[recmegslen]='\0';
        printf("OK: %s: %s\n",inet_ntoa(fromaddr.sin_addr),recbuf);
        //
        return(0);
}
Exemplo n.º 13
0
/* minimal header reading.  modify if you want to parse more information */
int RGBE_ReadHeader(FILE *fp, int *width, int *height, rgbe_header_info *info)
{
  char buf[128];
  int found_format;
  float tempf;
  int i;

  found_format = 0;
  if (info) {
    info->valid = 0;
    info->programtype[0] = 0;
    info->gamma = info->exposure = 1.0;
  }
  if (fgets(buf,sizeof(buf)/sizeof(buf[0]),fp) == NULL)
    return rgbe_error(rgbe_read_error,NULL);
  if ((buf[0] != '#')||(buf[1] != '?')) {
    /* if you want to require the magic token then uncomment the next line */
    /*return rgbe_error(rgbe_format_error,"bad initial token"); */
  }
  else if (info) {
    info->valid |= RGBE_VALID_PROGRAMTYPE;
    for(i=0;i<sizeof(info->programtype)-1;i++) {
      if ((buf[i+2] == 0) || isspace(buf[i+2]))
  break;
      info->programtype[i] = buf[i+2];
    }
    info->programtype[i] = 0;
    if (fgets(buf,sizeof(buf)/sizeof(buf[0]),fp) == 0)
      return rgbe_error(rgbe_read_error,NULL);
  }
  for(;;) {
#if 0
    if ((buf[0] == 0)||(buf[0] == '\n'))
      return rgbe_error(rgbe_format_error,"no FORMAT specifier found");
#endif
    if (((buf[0] == 0)||(buf[0] == '\n'))&&(found_format == 0))
      return rgbe_error(rgbe_format_error,"no FORMAT specifier found");
    else if (strcmp(buf,"FORMAT=32-bit_rle_rgbe\n") == 0) {
      found_format = 1;
#if 0
      break;       /* format found so break out of loop */
#endif
  }
    else if (info && (sscanf(buf,"GAMMA=%g",&tempf) == 1)) {
      info->gamma = tempf;
      info->valid |= RGBE_VALID_GAMMA;
    }
    else if (info && (sscanf(buf,"EXPOSURE=%g",&tempf) == 1)) {
      info->exposure = tempf;
      info->valid |= RGBE_VALID_EXPOSURE;
    }
    else if (strcmp(buf,"\n") == 0) {
    /* blank line found so break out of loop */
      break;
    }
    if (fgets(buf,sizeof(buf)/sizeof(buf[0]),fp) == 0)
      return rgbe_error(rgbe_read_error,NULL);
  }
  if (fgets(buf,sizeof(buf)/sizeof(buf[0]),fp) == 0)
    return rgbe_error(rgbe_read_error,NULL);
#if 0
  if (strcmp(buf,"\n") != 0)
    return rgbe_error(rgbe_format_error,
          "missing blank line after FORMAT specifier");
  if (fgets(buf,sizeof(buf)/sizeof(buf[0]),fp) == 0)
    return rgbe_error(rgbe_read_error,NULL);
#endif
  if (sscanf(buf,"-Y %d +X %d",height,width) < 2)
    return rgbe_error(rgbe_format_error,"missing image size specifier");
  return RGBE_RETURN_SUCCESS;
}
Exemplo n.º 14
0
static pascal OSStatus DBClientDataCallback (HIViewRef browser, DataBrowserItemID itemID, DataBrowserPropertyID property, DataBrowserItemDataRef itemData, Boolean changeValue)
{
	OSStatus 	err, result;
	CFStringRef	str;
	Boolean		r;
	uint32		address;
	uint8		value;
	char		code[256];

	result = noErr;

	switch (property)
	{
		case kCmCheckBox:
			ThemeButtonValue	buttonValue;

            if (changeValue)
			{
				err = GetDataBrowserItemDataButtonValue(itemData, &buttonValue);
				citem[itemID - 1].enabled = (buttonValue == kThemeButtonOn) ? true : false;
 	        }
			else
				err = SetDataBrowserItemDataButtonValue(itemData, citem[itemID - 1].enabled ? kThemeButtonOn : kThemeButtonOff);

			break;

		case kCmAddress:
			if (changeValue)
			{
				err = GetDataBrowserItemDataText(itemData, &str);
				r = CFStringGetCString(str, code, 256, CFStringGetSystemEncoding());
				CFRelease(str);
				if (r)
				{
					Boolean	translated;

					if (S9xProActionReplayToRaw(code, address, value) == NULL)
						translated = true;
					else
					if (S9xGameGenieToRaw(code, address, value) == NULL)
						translated = true;
					else
					{
						translated = false;
						if (sscanf(code, "%" SCNx32, &address) != 1)
							address = 0;
						else
							address &= 0xFFFFFF;
					}

					citem[itemID - 1].address = address;
					sprintf(code, "%06" PRIX32, address);
					str = CFStringCreateWithCString(kCFAllocatorDefault, code, CFStringGetSystemEncoding());
					err = SetDataBrowserItemDataText(itemData, str);
					CFRelease(str);

					if (translated)
					{
						DataBrowserItemID	id[1];

						citem[itemID - 1].value = value;
						id[0] = itemID;
						err = UpdateDataBrowserItems(browser, kDataBrowserNoItem, 1, id, kDataBrowserItemNoProperty, kCmValue);
					}
				}
			}
			else
			{
				sprintf(code, "%06" PRIX32, citem[itemID - 1].address);
				str = CFStringCreateWithCString(kCFAllocatorDefault, code, CFStringGetSystemEncoding());
				err = SetDataBrowserItemDataText(itemData, str);
				CFRelease(str);
			}

			break;

		case kCmValue:
			if (changeValue)
			{
				err = GetDataBrowserItemDataText(itemData, &str);
				r = CFStringGetCString(str, code, 256, CFStringGetSystemEncoding());
				CFRelease(str);
				if (r)
				{
					uint32	byte;

					if (sscanf(code, "%" SCNx32, &byte) == 1)
						citem[itemID - 1].value = (uint8) byte;
					else
					{
						citem[itemID - 1].value = 0;
						err = SetDataBrowserItemDataText(itemData, CFSTR("00"));
					}
				}
			}
			else
			{
				sprintf(code, "%02" PRIX8, citem[itemID - 1].value);
				str = CFStringCreateWithCString(kCFAllocatorDefault, code, CFStringGetSystemEncoding());
				err = SetDataBrowserItemDataText(itemData, str);
				CFRelease(str);
			}

			break;

		case kCmDescription:
			if (changeValue)
			{
				code[0] = 0;
				err = GetDataBrowserItemDataText(itemData, &str);
				strcpy(code, GetMultiByteCharacters(str, 19));
				CFRelease(str);

				if (code[0] == 0)
				{
					code[0] = ' ';
					code[1] = 0;
				}

				strcpy(citem[itemID - 1].description, code);
			}
			else
			{
				str = CFStringCreateWithCString(kCFAllocatorDefault, citem[itemID - 1].description, CFStringGetSystemEncoding());
				err = SetDataBrowserItemDataText(itemData, str);
				CFRelease(str);
			}

			break;

		case kDataBrowserItemIsActiveProperty:
			err = SetDataBrowserItemDataBooleanValue(itemData, true);
			break;

		case kDataBrowserItemIsEditableProperty:
			err = SetDataBrowserItemDataBooleanValue(itemData, true);
			break;

		default:
			result = errDataBrowserPropertyNotSupported;
	}

	return (result);
}
Exemplo n.º 15
0
static MagickBooleanType WriteXTRNImage(const ImageInfo *image_info,
                                        Image *image,ExceptionInfo *exception)
{
    Image *
    p;

    ImageInfo
    *clone_info;

    int
    scene;

    MagickBooleanType
    status;

    void
    *param1,
    *param2,
    *param3;

    param1 = param2 = param3 = (void *) NULL;
    status=MagickTrue;
    if (LocaleCompare(image_info->magick,"XTRNFILE") == 0)
    {
        clone_info=CloneImageInfo(image_info);
        *clone_info->magick='\0';
        status=WriteImage(clone_info,image,exception);
        if (status == MagickFalse)
            CatchImageException(image);
        clone_info=DestroyImageInfo(clone_info);
    }
    else if (LocaleCompare(image_info->magick,"XTRNIMAGE") == 0)
    {
        Image
        **image_ptr;

        ImageInfo
        **image_info_ptr;

        clone_info=CloneImageInfo(image_info);
        if (clone_info->filename[0])
        {
            (void) sscanf(clone_info->filename,"%lx,%lx",&param1,&param2);
            image_info_ptr=(ImageInfo **) param1;
            image_ptr=(Image **) param2;
            if ((image_info_ptr != (ImageInfo **) NULL) &&
                    (image_ptr != (Image **) NULL))
            {
                *image_ptr=CloneImage(image,0,0,MagickFalse,exception);
                *image_info_ptr=clone_info;
            }
        }
    }
    else if (LocaleCompare(image_info->magick,"XTRNBLOB") == 0)
    {
        char
        **blob_data;

        size_t
        *blob_length;

        char
        filename[MagickPathExtent];

        clone_info=CloneImageInfo(image_info);
        if (clone_info->filename[0])
        {
            (void) sscanf(clone_info->filename,"%lx,%lx,%2048s",
                          &param1,&param2,filename);

            blob_data=(char **) param1;
            blob_length=(size_t *) param2;
            scene = 0;
            (void) CopyMagickString(clone_info->filename,filename,
                                    MagickPathExtent);
            for (p=image; p != (Image *) NULL; p=GetNextImageInList(p))
            {
                (void) CopyMagickString(p->filename,filename,MagickPathExtent);
                p->scene=scene++;
            }
            SetImageInfo(clone_info,1,exception);
            (void) CopyMagickString(image->magick,clone_info->magick,
                                    MagickPathExtent);
            if (*blob_length == 0)
                *blob_length=8192;
            *blob_data=(char *) ImageToBlob(clone_info,image,blob_length,
                                            exception);
            if (*blob_data == NULL)
                status=MagickFalse;
            if (status == MagickFalse)
                CatchImageException(image);
        }
        clone_info=DestroyImageInfo(clone_info);
    }
    else if (LocaleCompare(image_info->magick,"XTRNARRAY") == 0)
    {
        char
        filename[MagickPathExtent];

        size_t
        blob_length;

        unsigned char
        *blob_data;

        clone_info=CloneImageInfo(image_info);
        if (*clone_info->filename != '\0')
        {
            (void) sscanf(clone_info->filename,"%lx,%2048s",&param1,filename);
            image->client_data=param1;
            scene=0;
            (void) CopyMagickString(clone_info->filename,filename,
                                    MagickPathExtent);
            for (p=image; p != (Image *) NULL; p=GetNextImageInList(p))
            {
                (void) CopyMagickString(p->filename,filename,MagickPathExtent);
                p->scene=scene++;
            }
            SetImageInfo(clone_info,1,exception);
            (void) CopyMagickString(image->magick,clone_info->magick,
                                    MagickPathExtent);
            blob_data=ImageToBlob(clone_info,image,&blob_length,
                                  exception);
            if (blob_data == (unsigned char *) NULL)
                status=MagickFalse;
            else
                SafeArrayFifo(image,blob_data,blob_length);
            if (status == MagickFalse)
                CatchImageException(image);
        }
        clone_info=DestroyImageInfo(clone_info);
    }
    return(MagickTrue);
}
Exemplo n.º 16
0
bool Image::loadPPM(const std::string &fname)
{
	clear();

/*	BaseTextFile file;
	file.addLineCommentDef("#");
	file.loadFile(fname, false);
	std::string type;
	file >> type;
	int nChannels;
	if (type == "P5")
		nChannels = 1;
	else if (type == "P6")
		nChannels = 3;
	else
		return false;
	int w, h;
	file >> w;
	file >> h;
	int dummy;
	file >> dummy;

	Console::print("%d %d %d\n", w, h, dummy);

	// Create the image
	create(w, h, nChannels, Image::I8BITS);

	// read the image data
	fread(&m_data[0], sizeof(unsigned char), m_data.size(), file.getFP());

	return true;
*/
	FILE *fp;
	char imageType[3],str[1024];

	// Read PGM image file with filename "file"

	// The PGM file format for a GREYLEVEL image is:
	// P5 (2 ASCII characters) <CR>
	// two ASCII numbers for nx ny (number of rows and columns <CR>
	// 255 (ASCII number) <CR>
	// binary pixel data with one byte per pixel

	// The PGM file format for a COLOR image is:
	// P6 (2 ASCII characters) <CR>
	// two ASCII numbers for nx ny (number of rows and columns <CR>
	// 255 (ASCII number) <CR>
	// binary pixel data with three bytes per pixel (one byte for eacg RGB)

	fp=fopen(fname.c_str(),"rb");
	if (!fp)
		return false;

	// read the first ASCII line to find out if we read a color image or
	// a greylevel image

	fgets(str,100,fp);
	sscanf(str,"%s",imageType);

	Format format = Image::I8BITS;
	int nChannels = 0;
	if(!strncmp(imageType,"P5",2)) // greylevel image
		nChannels = 1;
	else if(!strncmp(imageType,"P6",2)) // color image 
		nChannels = 3;
	else
		return false;

	// skip comments embedded in header
	fgets(str,1024,fp);  
	while(str[0]=='#')
		fgets(str,1024,fp);

	// read image dimensions 
	int w, h;
	sscanf(str,"%d %d", &w, &h);

	// read the next line into dummy variable
	fgets(str,1024,fp);

	// Create the image
	create(w, h, nChannels, format);
		
	// read the image data
	fread(&m_data[0], sizeof(unsigned char), w*h*m_bytesPerPixel, fp);

	fclose(fp);

	if (m_width==0 || m_height==0)
		return false;

	return true;
}
Exemplo n.º 17
0
/*	Receive data from host and call *callback ()
 *	@param waitress handle
 *	@return WaitressReturn_t
 */
WaitressReturn_t WaitressFetchCall (WaitressHandle_t *waith) {
	struct addrinfo hints, *res;
	int sockfd;
	char recvBuf[WAITRESS_RECV_BUFFER];
	char writeBuf[2*1024];
	ssize_t recvSize = 0;
	WaitressReturn_t wRet = WAITRESS_RET_OK;
	struct pollfd sockpoll;
	int pollres;
	/* header parser vars */
	char *nextLine = NULL, *thisLine = NULL;
	enum {HDRM_HEAD, HDRM_LINES, HDRM_FINISHED} hdrParseMode = HDRM_HEAD;
	char statusCode[3], val[256];
	unsigned int bufFilled = 0;

	/* initialize */
	waith->contentLength = 0;
	waith->contentReceived = 0;
	memset (&hints, 0, sizeof hints);

	hints.ai_family = AF_UNSPEC;
	hints.ai_socktype = SOCK_STREAM;

	/* Use proxy? */
	if (WaitressProxyEnabled (waith)) {
		if (getaddrinfo (waith->proxyHost, waith->proxyPort, &hints, &res) != 0) {
			return WAITRESS_RET_GETADDR_ERR;
		}
	} else {
		if (getaddrinfo (waith->host, waith->port, &hints, &res) != 0) {
			return WAITRESS_RET_GETADDR_ERR;
		}
	}

	if ((sockfd = socket (res->ai_family, res->ai_socktype, res->ai_protocol)) == -1) {
		freeaddrinfo (res);
		return WAITRESS_RET_SOCK_ERR;
	}
	sockpoll.fd = sockfd;

	fcntl (sockfd, F_SETFL, O_NONBLOCK);
	/* increase socket receive buffer */
	const int sockopt = 256*1024;
	setsockopt (sockfd, SOL_SOCKET, SO_RCVBUF, &sockopt, sizeof (sockopt));

	/* non-blocking connect will return immediately */
	connect (sockfd, res->ai_addr, res->ai_addrlen);

	sockpoll.events = POLLOUT;
	pollres = poll (&sockpoll, 1, waith->socktimeout);
	freeaddrinfo (res);
	if (pollres == 0) {
		return WAITRESS_RET_TIMEOUT;
	} else if (pollres == -1) {
		return WAITRESS_RET_ERR;
	}
	/* check connect () return value */
	socklen_t pollresSize = sizeof (pollres);
	getsockopt (sockfd, SOL_SOCKET, SO_ERROR, &pollres, &pollresSize);
	if (pollres != 0) {
		return WAITRESS_RET_CONNECT_REFUSED;
	}

	/* send request */
	if (WaitressProxyEnabled (waith)) {
		snprintf (writeBuf, sizeof (writeBuf),
			"%s http://%s:%s%s HTTP/1.0\r\n",
			(waith->method == WAITRESS_METHOD_GET ? "GET" : "POST"),
			waith->host, waith->port, waith->path);
	} else {
		snprintf (writeBuf, sizeof (writeBuf),
			"%s %s HTTP/1.0\r\n",
			(waith->method == WAITRESS_METHOD_GET ? "GET" : "POST"),
			waith->path);
	}
	WRITE_RET (writeBuf, strlen (writeBuf));

	snprintf (writeBuf, sizeof (writeBuf),
			"Host: %s\r\nUser-Agent: " PACKAGE "\r\n", waith->host);
	WRITE_RET (writeBuf, strlen (writeBuf));

	if (waith->method == WAITRESS_METHOD_POST && waith->postData != NULL) {
		snprintf (writeBuf, sizeof (writeBuf), "Content-Length: %zu\r\n",
				strlen (waith->postData));
		WRITE_RET (writeBuf, strlen (writeBuf));
	}
	
	if (waith->extraHeaders != NULL) {
		WRITE_RET (waith->extraHeaders, strlen (waith->extraHeaders));
	}
	
	WRITE_RET ("\r\n", 2);

	if (waith->method == WAITRESS_METHOD_POST && waith->postData != NULL) {
		WRITE_RET (waith->postData, strlen (waith->postData));
	}

	/* receive answer */
	nextLine = recvBuf;
	while (hdrParseMode != HDRM_FINISHED) {
		READ_RET (recvBuf+bufFilled, sizeof (recvBuf)-1 - bufFilled, &recvSize);
		if (recvSize == 0) {
			/* connection closed too early */
			CLOSE_RET (WAITRESS_RET_CONNECTION_CLOSED);
		}
		bufFilled += recvSize;
		memset (recvBuf+bufFilled, 0, sizeof (recvBuf) - bufFilled);
		thisLine = recvBuf;

		/* split */
		while ((nextLine = strchr (thisLine, '\n')) != NULL &&
				hdrParseMode != HDRM_FINISHED) {
			/* make lines parseable by string routines */
			*nextLine = '\0';
			if (*(nextLine-1) == '\r') {
				*(nextLine-1) = '\0';
			}
			/* skip \0 */
			++nextLine;

			switch (hdrParseMode) {
				/* Status code */
				case HDRM_HEAD:
					if (sscanf (thisLine, "HTTP/1.%*1[0-9] %3[0-9] ",
							statusCode) == 1) {
						if (memcmp (statusCode, "200", 3) == 0 ||
								memcmp (statusCode, "206", 3) == 0) {
							/* everything's fine... */
						} else if (memcmp (statusCode, "403", 3) == 0) {
							CLOSE_RET (WAITRESS_RET_FORBIDDEN);
						} else if (memcmp (statusCode, "404", 3) == 0) {
							CLOSE_RET (WAITRESS_RET_NOTFOUND);
						} else {
							CLOSE_RET (WAITRESS_RET_STATUS_UNKNOWN);
						}
						hdrParseMode = HDRM_LINES;
					} /* endif */
					break;

				/* Everything else, except status code */
				case HDRM_LINES:
					/* empty line => content starts here */
					if (*thisLine == '\0') {
						hdrParseMode = HDRM_FINISHED;
					} else {
						memset (val, 0, sizeof (val));
						if (sscanf (thisLine, "Content-Length: %255c", val) == 1) {
							waith->contentLength = atol (val);
						}
					}
					break;

				default:
					break;
			} /* end switch */
			thisLine = nextLine;
		} /* end while strchr */
		memmove (recvBuf, thisLine, thisLine-recvBuf);
		bufFilled -= (thisLine-recvBuf);
	} /* end while hdrParseMode */

	/* push remaining bytes */
	if (bufFilled > 0) {
		waith->contentReceived += bufFilled;
		if (waith->callback (thisLine, bufFilled, waith->data) ==
				WAITRESS_CB_RET_ERR) {
			CLOSE_RET (WAITRESS_RET_CB_ABORT);
		}
	}

	/* receive content */
	do {
		READ_RET (recvBuf, sizeof (recvBuf), &recvSize);
		if (recvSize > 0) {
			waith->contentReceived += recvSize;
			if (waith->callback (recvBuf, recvSize, waith->data) ==
					WAITRESS_CB_RET_ERR) {
				wRet = WAITRESS_RET_CB_ABORT;
				break;
			}
		}
	} while (recvSize > 0);

	close (sockfd);

	if (wRet == WAITRESS_RET_OK && waith->contentReceived < waith->contentLength) {
		return WAITRESS_RET_PARTIAL_FILE;
	}
	return wRet;
}
Exemplo n.º 18
0
/* initialize the epics record and the hardware */
static long dsetInit_devAiAsyncSerial(aiRecord *pai)
{
  CONTEXT *p_myContext;
  CALLBACK *p_myCallback;	
  char p_writeBuffer[BUFLEN];
  char p_readBuffer[BUFLEN];
  int myPrimaryAddress;
  int myPortNumber;
  int myParity;
  int myNumberOfDataBits;
  int myNumberOfStopBits;
  int myBaudRate;
  char p_myCommand[BUFLEN];

  #ifdef DEBUG1
  packageInfo();	
  printf(__FILE__ "[%d] -> %s (%s)\n", __LINE__, __func__, pai->name);
  #endif

				/* Parse the db file paramters		*/
				/* and set the value of key variables	*/
  if(sscanf(pai->inp.value.instio.string,
	 "spn=%d pad=%d br=%d nodb=%d p=%d nosb=%d c=%[^\n]",
	&myPortNumber, &myPrimaryAddress, &myBaudRate, 
	&myNumberOfDataBits, &myParity, &myNumberOfStopBits, p_myCommand)!=7) {
    printf( __FILE__ "[%d] Error: Couldn't parse the parameters correctly!", 
		    __LINE__ );
    printf( __FILE__ "[%d] >%s<!", __LINE__, pai->inp.value.instio.string );
    sleep(SLEEPTIME_ERROR);
    return(ERROR);
  } /* end_of_if */

  initSerialPort2(myPortNumber);
  setBaudRate2(myPortNumber,myBaudRate);
  setNumberOfDataBits2(myPortNumber,myNumberOfDataBits);
  setParity2(myPortNumber,myParity);
  setFlowControl2(myPortNumber,NO_FLOW_CONTROL); /* Required for this dev */
  setNumberOfStopBits2(myPortNumber,myNumberOfStopBits);

  #ifdef DEBUG2
  printf(__FILE__ "[%d] portNumber       = %d\n", 
		__LINE__, myPortNumber);
  printf(__FILE__ "[%d] primaryAddress   = %d\n", 
		__LINE__, myPrimaryAddress);
  printf(__FILE__ "[%d] baudRate         = %d\n", 
		__LINE__, getBaudRate2(myPortNumber));
  printf(__FILE__ "[%d] numberOfDataBits = %d\n",
		__LINE__, getNumberOfDataBits2(myPortNumber));
  printf(__FILE__ "[%d] parity           = %d\n", 
		__LINE__, getParity2(myPortNumber));
  printf(__FILE__ "[%d] numberOfStopBits = %d\n",
		__LINE__, getNumberOfStopBits2(myPortNumber));
  printf(__FILE__ "[%d] p_myCommand      = >%s<\n", 
		 __LINE__, p_myCommand); 
  #endif

  if (lockSerialPort2(myPortNumber,LOCK, pai->name)<=ERROR) {
	printf( __FILE__ "[%d] Error: Couldn't lock serial port (%s)\n",
			__LINE__, getSerialPortName2(myPortNumber));
	sleep(SLEEPTIME_ERROR);
	return(ERROR);
  }
  				/* Disable front panel 			*/
				/* This operation should work if 	*/
				/* communication parameters are ok	*/
  strcpy(p_writeBuffer,"XFRONT");
  strcat(p_writeBuffer,TERMINATOR); 

  openSerialPort2(myPortNumber);
  if (writeSerialPort2(myPortNumber, p_writeBuffer ) <= ERROR) {
	printf( __FILE__ "[%d] Error: Couldn't write on %s\n",
			__LINE__, getSerialPortName2(myPortNumber));
	sleep(SLEEPTIME_ERROR);
	return(ERROR);
  }
  usleep(USLEEPTIME_WRITE);

  memset(p_readBuffer,0,BUFLEN);

  if (readSerialPort2(myPortNumber, p_readBuffer, BUFLEN) <= ERROR) {
	printf( __FILE__ "[%d] Error: Couldn't read on %s\n",
			__LINE__, getSerialPortName2(myPortNumber));
	sleep(SLEEPTIME_ERROR);
	return(ERROR);
  }
  usleep(USLEEPTIME_READ);
  if (lockSerialPort2(myPortNumber,UNLOCK, pai->name)<=ERROR) {
    printf ( __FILE__ "Error");
    sleep(SLEEPTIME_ERROR);
    return(ERROR);
  }


  p_myCallback=(CALLBACK *)calloc(1,sizeof(CALLBACK));
  callbackSetCallback(myCallback_devAiAsyncSerial,p_myCallback);
  callbackSetUser(pai,p_myCallback);
 
  p_myContext=(CONTEXT *)calloc(1,sizeof(CONTEXT));
  p_myContext->portNumber=myPortNumber;
  p_myContext->p_callback=p_myCallback;
  p_myContext->primaryAddress=myPrimaryAddress;
  strncpy(p_myContext->p_command, p_myCommand, BUFLEN);
  pai->dpvt=(void *)p_myContext;

				/* Check acknowledgement		*/
  if (strncmp(p_readBuffer,"OK",2)!=0) {
      printf( __FILE__ "[%d] Error: Couldn't communicate with  %s\n",
		      __LINE__, pai->name);
      printf( __FILE__ "[%d] Check configuration parameters?\n", __LINE__);
      return(ERROR);
  }

  #ifdef DEBUG1
  printf( __FILE__ "[%d] <- %s\n", __LINE__, __func__);
  #endif

  return(SUCCESS);

} /* end init_press_record() */
Exemplo n.º 19
0
/* 
 * Read  and write all the ports specified in hex on the command line. 
 * The program uses the faster ioperm[set port IO permissions]/iopl[change IO privilege level] calls on x86. 
 * The program acts as inb/inw/inl according  to its own name.
 */
int port_io(int argc, char **argv)
{
    unsigned int i, n, port, size, error = 0;
	unsigned int val, opt;
    
    prgname = argv[0];
    switch (prgname[strlen(prgname)-1]) {
        case 'w': 
			size = 2; 
			break;
			
        case 'l': 
			size = 4; 
			break;
			
        case 'b': 
			
		case 'p': 
			
		default:
	    	size = 1;
    }
	
    setuid(0); 

	printf("Please choose the option: 1 - read, 2 - write: ");
	scanf("%d",&opt);

	if (opt == 1) {
	    for (i = 1; i < argc; i++) {
	        if ( sscanf(argv[i], "%x%n", &port, &n) < 1 || n != strlen(argv[i]) ) {
		    	fprintf(stderr, "%s: argument \"%s\" is not a hex number\n", argv[0], argv[i]);
				error++; 
				continue;
			}
			
			if (port & (size-1)) {
			    fprintf(stderr, "%s: argument \"%s\" is not properly aligned\n", argv[0], argv[i]);
			    error++; 
				continue;
			}
			
			error += read_one(port, size);
		}
	} else if (opt == 2) {
		for (i = 1; i < argc-1; i++) {
	        if ( sscanf(argv[i], "%x%n", &port, &n) < 1 || n != strlen(argv[i]) ) {
		    	fprintf(stderr, "%s: argument \"%s\" is not a hex number\n", argv[0], argv[i]);
		    	error++; 
				continue;
			}
			
			if (port & (size-1)) {
		    	fprintf(stderr, "%s: argument \"%s\" is not properly aligned\n", argv[0], argv[i]);
		    	error++; 
				continue;
			}
			
	        if ( sscanf(argv[i+1], "%x%n", &val, &n) < 1 || n != strlen(argv[i+1]) ) {
		    	fprintf(stderr, "%s: argument \"%s\" is not a hex number\n", argv[0], argv[i+1]);
		    	error++; 
				continue;
			}
			
			if (size < 4 && val > (size == 1 ? 0xff : 0xffff)) {
			    fprintf(stderr, "%s: argument \"%s\" out of range\n", argv[0], argv[i+1]);
			    error++; 
				continue;
			}
			
			error += write_one(port, val, size);
	    }
	}
	
    return (error ? 1 : 0);
}
Exemplo n.º 20
0
/* GZMAT */
int rgzmat(char *filename, int *atomnum, ATOM * atom, CONTROLINFO cinfo,
		   MOLINFO minfo)
{
        typedef struct {
                char name[MAXCHAR];
        } STRNAME;

	FILE *fpin;
	int i, j, index, index0;
	int overflow_flag = 0;
	int findindex;
	int numatom;
	int coordinate_flag = 0;
	STRNAME *bondstr;	
	STRNAME *anglestr;	
	STRNAME *twiststr;	
	char tmpchar1[MAXCHAR];
	char tmpchar2[MAXCHAR];
	char line[MAXCHAR];


	if ((fpin = fopen(filename, "r")) == NULL) {
		fprintf(stdout, "Cannot open the input file %s to read in rgzmat(), exit\n", filename);
		exit(1);
	}
        bondstr = (STRNAME *) malloc(sizeof(STRNAME) * (cinfo.maxatom +10));
        if (bondstr == NULL) {
                fprintf(stdout, "memory allocation error for *bondstr in rgzmat()\n");
                exit(1);
        }
        anglestr = (STRNAME *) malloc(sizeof(STRNAME) * (cinfo.maxatom +10));
        if (anglestr == NULL) {
                fprintf(stdout, "memory allocation error for *anglestr in rgzmat()\n");
                exit(1);
        }
        twiststr = (STRNAME *) malloc(sizeof(STRNAME) * (cinfo.maxatom +10));
        if (twiststr == NULL) {
                fprintf(stdout, "memory allocation error for *twiststr in rgzmat()\n");
                exit(1);
        }

	initial(cinfo.maxatom, atom, minfo.resname);
	index = 0;
	index0 = 1;
	numatom = 0;
	for (;;) {
		if (fgets(line, MAXCHAR, fpin) == NULL) {
/*       printf("\nFinished reading %s file.", cinfo.ifilename); */
			break;
		}
		if (spaceline(line) == 1) {
			if(coordinate_flag == 1) break;
			index++;
			continue;
		}
		if (index >= 2)
			index++;
		if (index <= 3)
			continue;
		if (index >= 4) {
			if (spaceline(line) == 1 || strncmp(line, "Vari", 4) == 0
				|| strncmp(line, "vari", 4) == 0)
				index0 = -1;
			if (strncmp(line, "Const", 5) == 0
				|| strncmp(line, "const", 5) == 0)
				index0 = -1;
		}
		if (index == 4) {
			if (overflow_flag == 0)
				sscanf(line, "%s", atom[numatom].name);
			numatom++;
			if (numatom >= cinfo.maxatom && overflow_flag == 0) {
				printf
					("\nInfo: the atom number exceeds the MAXATOM, reallocate memory automatically");
				overflow_flag = 1;
			}
			continue;
		}
		if (index == 5) {
			if (overflow_flag == 0) {
				sscanf(line, "%s%d%s", atom[numatom].name,
					   &atom[numatom].bondatom, bondstr[numatom].name);
				if(atom[numatom].bondatom > numatom) {
					printf("\nError: bond atom ID is larger than ID of current atom (%d,%s), exit", 
						numatom+1,  atom[numatom].name); 
					exit(1);
				}
			}
			numatom++;
			if (numatom >= cinfo.maxatom && overflow_flag == 0) {
				printf
					("\nInfo: the atom number exceeds the MAXATOM, reallocate memory automatically");
				overflow_flag = 1;
			}
			continue;
		}
		if (index == 6) {
			if (overflow_flag == 0) {
				sscanf(line, "%s%d%s%d%s", atom[numatom].name,
					   &atom[numatom].bondatom, bondstr[numatom].name,
					   &atom[numatom].angleatom, anglestr[numatom].name);
				if(atom[numatom].bondatom > numatom) {
					printf("\nError: bond atom ID is larger than ID of current atom (%d,%s), exit", 
						numatom+1,  atom[numatom].name); 
					exit(1);
				}
				if(atom[numatom].angleatom > numatom) {
					printf("\nError: angle atom ID is larger than ID of current atom (%d,%s), exit", 
						numatom+1,  atom[numatom].name); 
					exit(1);
				}
			}
			numatom++;
			if (numatom >= cinfo.maxatom && overflow_flag == 0) {
				printf
					("\nInfo: the atom number exceeds the MAXATOM, reallocate memory automatically");
				overflow_flag = 1;
			}
			continue;
		}
		if (index0 != -1) {
			if (overflow_flag == 0) {
				sscanf(line, "%s%d%s%d%s%d%s", atom[numatom].name,
					   &atom[numatom].bondatom, bondstr[numatom].name,
					   &atom[numatom].angleatom, anglestr[numatom].name,
					   &atom[numatom].twistatom, twiststr[numatom].name);
				if(atom[numatom].bondatom > numatom) {
					printf("\nError: bond atom ID is larger than ID of current atom (%d,%s), exit", 
						numatom+1,  atom[numatom].name); 
					exit(1);
				}
				if(atom[numatom].angleatom > numatom) {
					printf("\nError: angle atom ID is larger than ID of current atom (%d,%s), exit", 
						numatom+1,  atom[numatom].name); 
					exit(1);
				}
				if(atom[numatom].twistatom > numatom) {
					printf("\nError: torsional atom ID is larger than ID of current atom (%d,%s), exit", 
						numatom+1,  atom[numatom].name); 
					exit(1);
				}
			}
			numatom++;
			if (numatom >= cinfo.maxatom && overflow_flag == 0) {
				printf
					("\nInfo: the atom number exceeds the MAXATOM, reallocate memory automatically");
				overflow_flag = 1;
			}

			continue;
		}
		if (index0 == -1) {
         if (strchr(line, '=') == NULL)
             continue;
			coordinate_flag = 1;
			for(i=0;i<strlen(line);i++)
                       		if(line[i] == '=') line[i] = ' ';
			sscanf(line, "%s %s", tmpchar1, tmpchar2);
			for (i = 1; i < numatom; i++) {
				findindex = 1;
				for (j = 0; j < strlen(bondstr[i].name); j++)
					if (bondstr[i].name[j] != tmpchar1[j]) {
						findindex = 0;
						break;
					}
				if (findindex == 1) {
					strcpy(bondstr[i].name, tmpchar2);
					break;
				}

			}
			for (i = 2; i < numatom; i++) {
				findindex = 1;
				for (j = 0; j < strlen(anglestr[i].name); j++)
					if (anglestr[i].name[j] != tmpchar1[j]) {
						findindex = 0;
						break;
					}
				if (findindex == 1) {
					strcpy(anglestr[i].name, tmpchar2);
					break;
				}
			}
			for (i = 3; i < numatom; i++) {
				findindex = 1;
				for (j = 0; j < strlen(twiststr[i].name); j++)
					if (twiststr[i].name[j] != tmpchar1[j]) {
						findindex = 0;
						break;
					}
				if (findindex == 1) {
					strcpy(twiststr[i].name, tmpchar2);
					break;
				}
			}
		}
	}
	atom[1].bondatom--;
	atom[2].bondatom--;
	atom[2].angleatom--;
	for (i = 3; i < numatom; i++) {
		atom[i].bondatom--;
		atom[i].angleatom--;
		atom[i].twistatom--;
	}
	for (i = 1; i < numatom; i++)
		atom[i].bond = atof(bondstr[i].name);
	for (i = 2; i < numatom; i++)
		atom[i].angle = atof(anglestr[i].name);
	for (i = 3; i < numatom; i++)
		atom[i].twist = atof(twiststr[i].name);
	*atomnum = numatom;
/* printf("\n atom number is  %5d", *atomnum); */
	fclose(fpin);
	free(bondstr);
	free(anglestr);
	free(twiststr);
	return overflow_flag;

}
// Attempts to load the texture from the source.
bool TextureResource::Load(RenderInterface* render_interface) const
{
	// Check for special loader tokens.
	if (!source.Empty() &&
		source[0] == '?')
	{
		Vector2i dimensions;

		bool delete_data = false;
		const byte* data = NULL;

		// Find the generation protocol and generate the data accordingly.
		String protocol = source.Substring(1, source.Find("::") - 1);
		if (protocol == "font")
		{
			// The requested texture is a font layer.
			delete_data = true;

			FontFaceHandle* handle;
			FontEffect* layer_id;
			int layout_id;
			int texture_id;

			if (sscanf(source.CString(), "?font::%p/%p/%d/%d", &handle, &layer_id, &layout_id, &texture_id) == 4)
			{
				handle->GenerateLayerTexture(data,
											 dimensions,
											 layer_id,
											 layout_id,
											 texture_id);
			}
		}

		// If texture data was generated, great! Otherwise, fallback to the LoadTexture() code and
		// hope the client knows what the hell to do with the question mark in their file name.
		if (data != NULL)
		{
			TextureHandle handle;
			bool success = render_interface->GenerateTexture(handle, data, dimensions);

			if (delete_data)
				delete[] data;

			if (success)
			{
				texture_data[render_interface] = TextureData(handle, dimensions);
				return true;
			}
			else
			{
				Log::Message(Log::LT_WARNING, "Failed to generate internal texture %s.", source.CString());
				texture_data[render_interface] = TextureData(0, Vector2i(0, 0));

				return false;
			}
		}
	}

	TextureHandle handle;
	Vector2i dimensions;
	if (!render_interface->LoadTexture(handle, dimensions, source))
	{
		Log::Message(Log::LT_WARNING, "Failed to load texture from %s.", source.CString());
		texture_data[render_interface] = TextureData(0, Vector2i(0, 0));

		return false;
	}

	texture_data[render_interface] = TextureData(handle, dimensions);
	return true;
}
Exemplo n.º 22
0
void wgzmat(char *filename, int atomnum, ATOM atom[], MOLINFO minfo)
{
        FILE *fpin;
        FILE *fpout;
        char *amberhome;
        char espparm_file[MAXCHAR];
        char line[MAXCHAR];
        char akeyword[MAXCHAR]="";
        char ckeyword[MAXCHAR];
	char tmpchar0[MAXCHAR];
	char tmpchar1[MAXCHAR];
	char tmpchar2[MAXCHAR];
	char tmpchar3[MAXCHAR];
        int i,j;
        int iradius_flag;
        int ibs= 0;
        int esp_flag;
        int nespparm = 0;
        int nbasisset = 0;
        double default_radius = 1.7;
        ESPPARM espparm[120];
        BASISSET basisset[100];


	if ((fpout = fopen(filename, "w")) == NULL) {
		fprintf(stdout, "Cannot open a file %s to write in wgzmat(), exit\n", filename);
		exit(1);
	}
	intercoord(atomnum, atom);
        fprintf(fpout, "%s\n", "--Link1--");
	if(strlen(minfo.gn) >= 5) 
		fprintf(fpout, "%s\n", minfo.gn);
	fprintf(fpout, "%s%s\n", "%chk=", minfo.chkfile);
	if(strlen(minfo.gm) >= 4) 
		fprintf(fpout, "%s\n", minfo.gm);

//      check ESP-related keyword
        esp_flag = 0;
	for(i=0;i<strlen(minfo.gkeyword);i++)
		ckeyword[i] = toupper(minfo.gkeyword[i]);
        if((strstr(ckeyword, "POP=") != 0 || strstr(ckeyword, "POP(")  != 0)  &&
           (strstr(ckeyword, "MK")   != 0 || strstr(ckeyword, "CHELP") != 0)) 
                esp_flag = 1;
//      when the default gaussian keyword is used, or esp_flag ==1, read ESP.PARM
        if(minfo.igkeyword == 0 || esp_flag == 1) {
                amberhome = (char *) getenv("AMBERHOME");
                if( amberhome == NULL ){
                        fprintf( stdout, "AMBERHOME is not set!\n" );
                        exit(1);
                }
                strcpy(espparm_file, amberhome);
                strcat(espparm_file, "/dat/antechamber/ESPPARM.DAT");
                if ((fpin = fopen(espparm_file, "r")) == NULL) {
                        fprintf(stdout, "Cannot open espparm_file %s in read_espparm(), exit\n", espparm_file);
                        exit(1);
                }
                for (;;) {
                        if (fgets(line, MAXCHAR, fpin) == NULL) break;
                        if(strncmp(line, "DEFAULT RADIUS", 14) == 0)
                                sscanf(&line[14], "%lf", &default_radius);
                        if(strncmp(line, "BASIS SET", 9) == 0) {
                                sscanf(&line[9], "%d%s", &basisset[nbasisset].id,
                                                           basisset[nbasisset].bs);
                                nbasisset++;
                        }
                        if(strncmp(line, "PARM", 4) == 0) {
                                sscanf(&line[4], "%ld%s%lf%lf%d%d", &espparm[nespparm].atomicnum, espparm[nespparm].elem,
                                                                    &espparm[nespparm].vdw,      &espparm[nespparm].mk,
                                                                    &espparm[nespparm].flag,     &espparm[nespparm].bs);
                                nespparm++;
                        }
                }
                fclose(fpin);

                iradius_flag = 0;
                ibs = 0;
                for(i=0;i<atomnum;i++) {
                        for(j=0;j<nespparm;j++)
                                if(atom[i].atomicnum == espparm[j].atomicnum || strcmp(atom[i].element, espparm[j].elem) == 0) {
                                        if(ibs < espparm[j].bs) ibs=espparm[j].bs;
                                        if(espparm[j].flag != 0) {
                                                iradius_flag = 1;
                                                espparm[j].flag = 2;
                                        }
                                        break;
                                }
                }

                if(minfo.igkeyword == 0) {
                        strcpy(minfo.gkeyword, "#HF/");
                        strcat(minfo.gkeyword, basisset[ibs-1].bs);
                        strcat(minfo.gkeyword, " SCF=tight Test Pop=MK iop(6/33=2) iop(6/42=6) opt");
                }
        }
//      additional keywords
        if(esp_flag == 1) {
                if(iradius_flag == 1) {
                        if(strstr(minfo.gkeyword, "ReadRadii") == 0 &&
                           strstr(minfo.gkeyword, "READRADII") == 0 &&
                           strstr(minfo.gkeyword, "readradii") == 0) {
                                strcat(akeyword, "Pop=ReadRadii");
                        }
                }
                if(minfo.gv == 1) {
                        if(strstr(minfo.gkeyword, "6/50=1") == 0) {
                                strcat(akeyword, " iop(6/50=1)");
                        }
                }
        }

        if(strlen(akeyword) >= 1) {
                fprintf(fpout, "%s\n", minfo.gkeyword);
                fprintf(fpout, "#%s\n", akeyword);
                fprintf(fpout, "\n", minfo.gkeyword);
        }
        else
                fprintf(fpout, "%s\n\n", minfo.gkeyword);
	fprintf(fpout, "%s\n\n", "remark line goes here");
	fprintf(fpout, "%d%4d\n", minfo.icharge, minfo.multiplicity);
	element(atomnum, atom);
	for (i = 0; i < atomnum; i++) {
		/* newitoa(i + 1, tmpchar0); */
		sprintf(tmpchar0, "%d", i+1);
		if (i == 0) {
			fprintf(fpout, "%5s\n", atom[i].element);
			continue;
		}
		if (i == 1) {
			strcpy(tmpchar1, "b");
			strcat(tmpchar1, tmpchar0);
			fprintf(fpout, "%5s%5d%8s\n", atom[i].element,
					atom[i].bondatom + 1, tmpchar1);
			continue;
		}
		if (i == 2) {
			strcpy(tmpchar1, "b");
			strcat(tmpchar1, tmpchar0);
			fprintf(fpout, "%5s%5d%8s", atom[i].element,
					atom[i].bondatom + 1, tmpchar1);
			strcpy(tmpchar2, "a");
			strcat(tmpchar2, tmpchar0);
			fprintf(fpout, "%5d%8s\n", atom[i].angleatom + 1, tmpchar2);
			continue;
		}
		strcpy(tmpchar1, "b");
		strcat(tmpchar1, tmpchar0);
		fprintf(fpout, "%5s%5d%8s", atom[i].element, atom[i].bondatom + 1,
				tmpchar1);
		strcpy(tmpchar2, "a");
		strcat(tmpchar2, tmpchar0);
		fprintf(fpout, "%5d%8s", atom[i].angleatom + 1, tmpchar2);
		strcpy(tmpchar3, "t");
		strcat(tmpchar3, tmpchar0);
		fprintf(fpout, "%5d%8s\n", atom[i].twistatom + 1, tmpchar3);
	}

	fprintf(fpout, "Variables:\n");
	fprintf(fpout, "b2= %8.4lf\n", atom[1].bond);
	fprintf(fpout, "b3= %8.4lf\n", atom[2].bond);
	fprintf(fpout, "a3= %8.4lf\n", atom[2].angle);
	for (i = 3; i < atomnum; i++) {
		/* newitoa(i + 1, tmpchar0); */
		sprintf(tmpchar0, "%d", i+1);
		strcpy(tmpchar1, "b");
		strcat(tmpchar1, tmpchar0);
		strcpy(tmpchar2, "a");
		strcat(tmpchar2, tmpchar0);
		strcpy(tmpchar3, "t");
		strcat(tmpchar3, tmpchar0);
		fprintf(fpout, "%s= %8.4lf\n", tmpchar1, atom[i].bond);
		fprintf(fpout, "%s= %8.4lf\n", tmpchar2, atom[i].angle);
		fprintf(fpout, "%s= %8.4lf\n", tmpchar3, atom[i].twist);
	}
        if(esp_flag == 1) {
                if(minfo.gv == 1 && iradius_flag == 1) {
                        for(i=0;i<nespparm;i++)
                                if(espparm[i].flag == 2) {
                                        if(espparm[i].mk <= 0) espparm[i].mk=default_radius;
                                        fprintf(fpout, "\n%s     %8.2lf", espparm[i].elem, espparm[i].mk);
                                }
                        fprintf(fpout, "\n\n%s\n", minfo.gesp);
                        for(i=0;i<nespparm;i++)
                                if(espparm[i].flag == 2) {
                                        if(espparm[i].mk <= 0) espparm[i].mk=default_radius;
                                        fprintf(fpout, "\n%s     %8.2lf", espparm[i].elem, espparm[i].mk);
                                }
                        fprintf(fpout, "\n\n%s\n", minfo.gesp);
                }
                if(minfo.gv == 0 && iradius_flag == 1) {
                        for(i=0;i<nespparm;i++)
                                if(espparm[i].flag == 2) {
                                        if(espparm[i].mk <= 0) espparm[i].mk=default_radius;
                                        fprintf(fpout, "\n%s     %8.2lf", espparm[i].elem, espparm[i].mk);
                                }
                        fprintf(fpout, "\n");
                        for(i=0;i<nespparm;i++)
                                if(espparm[i].flag == 2) {
                                        if(espparm[i].mk <= 0) espparm[i].mk=default_radius;
                                        fprintf(fpout, "\n%s     %8.2lf", espparm[i].elem, espparm[i].mk);
                                }
                        fprintf(fpout, "\n");
                }
                if(minfo.gv == 1 && iradius_flag == 0) {
                        fprintf(fpout, "\n%s\n", minfo.gesp);
                        fprintf(fpout, "\n%s\n", minfo.gesp);
                }
        }
	fprintf(fpout, "\n\n");
	fclose(fpout);
}
Exemplo n.º 23
0
void
KPaletteTable::readNamedColor( void )
{
  if( mNamedColorList->count() != 0 )
  {
    return; // Strings already present
  }

  TDEGlobal::locale()->insertCatalogue("tdelibs_colors");

  //
  // Code somewhat inspired by KPalette.
  //

  const char * const *path = namedColorFilePath();
  for( int i=0; path[i]; ++i )
  {
    TQFile paletteFile( path[i] );
    if( !paletteFile.open( IO_ReadOnly ) )
    {
      continue;
    }

    TQString line;
    TQStringList list;
    while( paletteFile.readLine( line, 100 ) != -1 )
    {
      int red, green, blue;
      int pos = 0;

      if( sscanf(line.ascii(), "%d %d %d%n", &red, &green, &blue, &pos ) == 3 )
      {
	//
	// Remove duplicates. Every name with a space and every name
	// that start with "gray".
	//
	TQString name = line.mid(pos).stripWhiteSpace();
	if( name.isNull() || name.find(' ') != -1 ||
	    name.find( "gray" ) != -1 ||  name.find( "grey" ) != -1 )
	{
	  continue;
	}

        const TQColor color ( red, green, blue );
        if ( color.isValid() )
        {
            const TQString colorName( i18n("color", name.latin1() ) );
            list.append( colorName );
            d->m_namedColorMap[ colorName ] = color;
        }
      }
    }

    list.sort();
    mNamedColorList->insertStringList( list );
    break;
  }

  if( mNamedColorList->count() == 0 )
  {
    //
    // Give the error dialog box a chance to center above the
    // widget (or dialog). If we had displayed it now we could get a
    // situation where the (modal) error dialog box pops up first
    // preventing the real dialog to become visible until the
    // error dialog box is removed (== bad UI).
    //
    TQTimer::singleShot( 10, this, TQT_SLOT(slotShowNamedColorReadError()) );
  }
}
Exemplo n.º 24
0
int main(int argc, char *argv[])
{
  char inFile[512], *configFile=NULL, type[10];
  const int pid = getpid();
  extern int logflag, quietflag;
  int quiet_f;  /* log_f is a static global */
  int createFlag = FLAG_NOT_SET; // create configuration file flag
  int configFlag = FLAG_NOT_SET; // use configuration file flag

  logflag = quietflag = FALSE;
  log_f = quiet_f = FLAG_NOT_SET;

  // Begin command line parsing ***********************************************
  if (   (checkForOption("--help", argc, argv) != FLAG_NOT_SET)
      || (checkForOption("-h", argc, argv) != FLAG_NOT_SET)
      || (checkForOption("-help", argc, argv) != FLAG_NOT_SET) ) {
      print_help();
  }
  get_asf_share_dir_with_argv0(argv[0]);
  handle_license_and_version_args(argc, argv, ASF_NAME_STRING);

  // Check which options were provided
  log_f    = checkForOption("-log", argc, argv);
  quiet_f  = checkForOption("-quiet", argc, argv);
  createFlag = checkForOption("-create", argc, argv);
  configFlag = checkForOption("-config", argc, argv);

  // We need to make sure the user specified the proper number of arguments
  int needed_args = 1 + REQUIRED_ARGS; // command & REQUIRED_ARGS
  int num_flags = 0;
  if (log_f != FLAG_NOT_SET) {needed_args += 2; num_flags++;} // option & param
  if (quiet_f != FLAG_NOT_SET) {needed_args += 1; num_flags++;} // option
  if (createFlag != FLAG_NOT_SET) {needed_args += 3; num_flags++;} // option & params
  if (configFlag != FLAG_NOT_SET) {needed_args += 2; num_flags++;} // option & param

  // Make sure we have the right number of args
  if(argc != needed_args) {
    print_usage();
  }

  // Make sure all options occur before the config file name argument
  if (num_flags == 1 &&
      (log_f   > 1 ||
       quiet_f > 1))
  {
    print_usage();
  }
  else if (num_flags > 1 &&
	   (log_f   >= argc - REQUIRED_ARGS - 1 ||
            quiet_f >= argc - REQUIRED_ARGS - 1))
  {
    print_usage();
  }

  // Make sure that only one option is used
  if (createFlag != FLAG_NOT_SET && configFlag != FLAG_NOT_SET)
    asfPrintError("The tool can either create or use the "
		  "configuration file, not both!\n");

  // Do the actual flagging & such for each flag
  if (createFlag != FLAG_NOT_SET) {
    sprintf(type, "%s", argv[createFlag+1]);
    configFile = (char *) MALLOC(sizeof(char)*1024);
    sprintf(configFile, "%s", argv[createFlag+2]);
  }
  if (configFlag != FLAG_NOT_SET) {
    configFile = (char *) MALLOC(sizeof(char)*1024);
    sprintf(configFile, "%s", argv[configFlag+1]);
  }
  if (log_f != FLAG_NOT_SET) {
    strcpy(logFile, argv[log_f+1]);
  }
  else {
    // default behavior: log to tmp<pid>.log
    sprintf(logFile, "tmp%i.log", pid);
  }
  logflag = TRUE;
  fLog = FOPEN(logFile, "a");
  // Set old school quiet flag (for use in our libraries)
  quietflag = quiet_f != FLAG_NOT_SET;

  // Fetch required arguments
  strcpy(inFile, argv[argc-1]);

  // Report the command line
  asfSplashScreen(argc, argv);

  // Initialze structure
  dataset_t *data = (dataset_t *) MALLOC(sizeof(dataset_t));

  strcpy(data->dataset_id, MAGIC_UNSET_STRING);
  strcpy(data->origin, MAGIC_UNSET_STRING);
  strcpy(data->title, MAGIC_UNSET_STRING);
  strcpy(data->online_link, MAGIC_UNSET_STRING);
  data->west_bounding = MAGIC_UNSET_DOUBLE;
  data->east_bounding = MAGIC_UNSET_DOUBLE;
  data->north_bounding = MAGIC_UNSET_DOUBLE;
  data->south_bounding = MAGIC_UNSET_DOUBLE;
  data->near_start_lat = MAGIC_UNSET_DOUBLE;
  data->near_start_lon = MAGIC_UNSET_DOUBLE;
  data->far_start_lat = MAGIC_UNSET_DOUBLE;
  data->far_start_lon = MAGIC_UNSET_DOUBLE;
  data->far_end_lat = MAGIC_UNSET_DOUBLE;
  data->far_end_lon = MAGIC_UNSET_DOUBLE;
  data->near_end_lat = MAGIC_UNSET_DOUBLE;
  data->near_end_lon = MAGIC_UNSET_DOUBLE;
  data->center_lat = MAGIC_UNSET_DOUBLE;
  data->center_lon = MAGIC_UNSET_DOUBLE;
  strcpy(data->processing_level, MAGIC_UNSET_STRING);
  strcpy(data->platform, MAGIC_UNSET_STRING);
  strcpy(data->instrument, MAGIC_UNSET_STRING);
  data->band_count = MAGIC_UNSET_INT;
  data->browse_location = NULL;
  data->browse_format = NULL;
  strcpy(data->access, MAGIC_UNSET_STRING);
  strcpy(data->copyright, MAGIC_UNSET_STRING);
  data->start_time = NULL;
  data->center_time = NULL;
  data->end_time = NULL;
  strcpy(data->orbit_direction, MAGIC_UNSET_STRING);
  strcpy(data->mode, MAGIC_UNSET_STRING);
  strcpy(data->spatial_reference, MAGIC_UNSET_STRING);
  strcpy(data->cell_value, MAGIC_UNSET_STRING);
  strcpy(data->raster_object, MAGIC_UNSET_STRING);
  data->row_count = MAGIC_UNSET_INT;
  data->col_count = MAGIC_UNSET_INT;
  strcpy(data->format, MAGIC_UNSET_STRING);
  data->fees = MAGIC_UNSET_DOUBLE;

  // Open XML for reading
  xmlDoc *doc = xmlReadFile(inFile, NULL, 0);
  if (!doc)
    asfPrintError("Could not parse metadata file (%s)\n", inFile);

  // Read in all parameters and perform error checking
  char string[512], tmp[255], errorMessage[8192]="Metadata parsing errors:\n";
  int nValue, error = FALSE;
  double fValue;

  // Dataset ID
  strcpy(string, xml_get_string_value(doc, "metadata.idinfo.datsetid"));
  if (strlen(string) > MAX_DATASET_ID) {
    error = TRUE;
    sprintf(tmp, "Dataset ID - String length: %d, allowed characters: %d\n", 
	    (int) strlen(string), MAX_DATASET_ID);
    strcat(errorMessage, tmp);
  }
  else {
    strcpy(data->dataset_id, 
	   xml_get_string_value(doc, "metadata.idinfo.datsetid"));
    //printf("Dataset ID: %s\n", data->dataset_id);
  }

  // Origin
  strcpy(string, xml_get_string_value(doc, 
    "metadata.idinfo.citation.citeinfo.origin"));
  if (strlen(string) > MAX_ORIGIN) {
    error = TRUE;
    sprintf(tmp, "Origin - String length: %d, allowed characters: %d\n",
	    (int) strlen(string), MAX_ORIGIN);
    strcat(errorMessage, tmp);
  }
  else {
    strcpy(data->origin, xml_get_string_value(doc, 
      "metadata.idinfo.citation.citeinfo.origin"));
    //printf("Origin: %s\n", data->origin);
  }

  // Title
  strcpy(string, xml_get_string_value(doc, 
    "metadata.idinfo.citation.citeinfo.title"));
  if (strlen(string) > MAX_TITLE) {
    error = TRUE;
    sprintf(tmp, "Title - String length: %d, allowed characters: %d\n",
	    (int) strlen(string), MAX_TITLE);
    strcat(errorMessage, tmp);
  }
  else {
    strcpy(data->title, xml_get_string_value(doc, 
      "metadata.idinfo.citation.citeinfo.title"));
    //printf("Title: %s\n", data->title);
  }

  // Online link
  strcpy(string, xml_get_string_value(doc, 
    "metadata.idinfo.citation.citeinfo.onlink"));
  if (strlen(string) > MAX_ONLINE_LINK) {
    error = TRUE;
    sprintf(tmp, "Online link - String length: %d, allowed characters: %d\n",
	    (int) strlen(string), MAX_ONLINE_LINK);
    strcat(errorMessage, tmp);
  }
  else {
    strcpy(data->online_link, xml_get_string_value(doc, 
      "metadata.idinfo.citation.citeinfo.onlink"));
    //printf("Online link: %s\n", data->online_link);
  }

  // West bounding coordinate
  fValue = xml_get_double_value(doc, "metadata.idinfo.spdom.bounding.westbc");
  if (fValue < -180.0 || fValue > 180.0) {
    error = TRUE;
    sprintf(tmp, "West bounding coordinate - Value (%.4lf) outside the "
	    "expected value range (-180.0 < value < 180.0)\n", fValue);
    strcat(errorMessage, tmp);
  }
  else {
    data->west_bounding =
      xml_get_double_value(doc, "metadata.idinfo.spdom.bounding.westbc");
    //printf("West bounding coordinate: %.4lf\n", data->west_bounding);
  }

  // East bounding coordinate
  fValue = xml_get_double_value(doc, "metadata.idinfo.spdom.bounding.eastbc");
  if (fValue < -180.0 || fValue > 180.0) {
    error = TRUE;
    sprintf(tmp, "East bounding coordinate - Value (%.4lf) outside the "
	    "expected value range (-180.0 < value < 180.0)\n", fValue);
    strcat(errorMessage, tmp);
  }
  else {
    data->east_bounding =
      xml_get_double_value(doc, "metadata.idinfo.spdom.bounding.eastbc");
    //printf("East bounding coordinate: %.4lf\n", data->east_bounding);
  }

  // North bounding coordinate
  fValue = xml_get_double_value(doc, "metadata.idinfo.spdom.bounding.northbc");
  if (fValue < -90.0 || fValue > 90.0) {
    error = TRUE;
    sprintf(tmp, "West bounding coordinate - Value (%.4lf) outside the "
	    "expected value range (-90.0 < value < 90.0)\n", fValue);
    strcat(errorMessage, tmp);
  }
  else {
    data->north_bounding =
      xml_get_double_value(doc, "metadata.idinfo.spdom.bounding.northbc");
    //printf("West bounding coordinate: %.4lf\n", data->north_bounding);
  }

  // South bounding coordinate
  fValue = xml_get_double_value(doc, "metadata.idinfo.spdom.bounding.southbc");
  if (fValue < -90.0 || fValue > 90.0) {
    error = TRUE;
    sprintf(tmp, "South bounding coordinate - Value (%.4lf) outside the "
	    "expected value range (-90.0 < value < 90.0)\n", fValue);
    strcat(errorMessage, tmp);
  }
  else {
    data->south_bounding =
      xml_get_double_value(doc, "metadata.idinfo.spdom.bounding.southbc");
    //printf("South bounding coordinate: %.4lf\n", data->south_bounding);
  }

  // Open KML for reading
  char centerFile[512], boundaryFile[512], *baseName;
  char coordStr[50];
  float height;
  baseName = get_basename(inFile);
  sprintf(boundaryFile, "%s_boundary.kml", baseName);
  sprintf(centerFile, "%s_center.kml", baseName);

  xmlDoc *xmlBoundary = xmlReadFile(boundaryFile, NULL, 0);
  if (!xmlBoundary)
    asfPrintError("Could not parse boundary file (%s)\n", boundaryFile);
  else {
    strcpy(coordStr, xml_get_string_value(xmlBoundary, 
      "kml.Document.Placemark.Polygon.outerBoundaryIs.LinearRing.coordinates"));    sscanf(coordStr, "%f,%f,%f\n%f,%f,%f\n%f,%f,%f\n%f,%f", 
	   &data->near_start_lat, &data->near_start_lon, &height,
	   &data->near_end_lat, &data->near_end_lon, &height,
	   &data->far_end_lat, &data->far_end_lon, &height,
	   &data->far_start_lat, &data->far_start_lon);
    //printf("Near start latitude: %.4f\n", data->near_start_lat);
    //printf("Near start longitude: %.4f\n", data->near_start_lon);
    //printf("Near end latitude: %.4f\n", data->near_end_lat);
    //printf("Near end longitude: %.4f\n", data->near_end_lon);
    //printf("Far start latitude: %.4f\n", data->far_start_lat);
    //printf("Far start longitude: %.4f\n", data->far_start_lon);
    //printf("Far end latitude: %.4f\n", data->far_end_lat);
    //printf("Far end longitude: %.4f\n", data->far_end_lon);
  }
  xmlFreeDoc(xmlBoundary);

  xmlDoc *xmlCenter = xmlReadFile(centerFile, NULL, 0);
  if (!xmlCenter)
    asfPrintWarning("Could not parse center point file (%s)\n", centerFile);
  else {
    strcpy(coordStr, xml_get_string_value(xmlCenter, 
      "kml.Document.Placemark.Point.coordinates"));
    sscanf(coordStr, "%f,%f", &data->center_lat, &data->center_lon);
    //printf("Center latitude: %.4f\n", data->center_lat);
    //printf("Center longitude: %.4f\n", data->center_lon);
  }
  xmlFreeDoc(xmlCenter);

  // Processing level
  strcpy(string, xml_get_string_value(doc, 
    "metadata.idinfo.proclevl.prolevid"));
  if (strlen(string) > MAX_PROCESSING_LEVEL) {
    error = TRUE;
    sprintf(tmp, 
	    "Processing level - String length: %d, allowed characters: %d\n",
	    (int) strlen(string), MAX_PROCESSING_LEVEL);
    strcat(errorMessage, tmp);
  }
  else {
    strcpy(data->processing_level, xml_get_string_value(doc, 
      "metadata.idinfo.proclevl.prolevid"));
    //printf("Processing level: %s\n", data->processing_level);
  }

  // Place
  strcpy(string, xml_get_string_value(doc, 
    "metadata.idinfo.keywords.place.placekey[0]"));
  if (strlen(string) > MAX_PLACE) {
    error = TRUE;
    sprintf(tmp, 
	    "Place - String length: %d, allowed characters: %d\n",
	    (int) strlen(string), MAX_PLACE);
    strcat(errorMessage, tmp);
  }
  else {
    data->place = (char *) MALLOC(sizeof(char)*MAX_PLACE);
    strcpy(data->place, xml_get_string_value(doc, 
      "metadata.idinfo.keywords.place.placekey[0]"));
    //printf("Place: %s\n", data->place);
  }

  // Platform
  strcpy(string, xml_get_string_value(doc, 
    "metadata.idinfo.plainsid.platflnm"));
  if (strlen(string) > MAX_PLATFORM) {
    error = TRUE;
    sprintf(tmp, "Platform - String length: %d, allowed characters: %d\n",
	    (int) strlen(string), MAX_PLATFORM);
    strcat(errorMessage, tmp);
  }
  else {
    strcpy(data->platform, xml_get_string_value(doc, 
      "metadata.idinfo.plainsid.platflnm"));
    //printf("Platform: %s\n", data->platform);
  }

  // Instrument
  strcpy(string, xml_get_string_value(doc, 
    "metadata.idinfo.plainsid.instflnm"));
  if (strlen(string) > MAX_INSTRUMENT) {
    error = TRUE;
    sprintf(tmp, "Instrument - String length: %d, allowed characters: %d\n",
	    (int) strlen(string), MAX_INSTRUMENT);
    strcat(errorMessage, tmp);
  }
  else {
    strcpy(data->instrument, xml_get_string_value(doc, 
      "metadata.idinfo.plainsid.instflnm"));
    //printf("Instrument: %s\n", data->instrument);
  }

  // Number of bands
  nValue = xml_get_int_value(doc, "metadata.idinfo.bandidnt.numbands");
  if (nValue < 0) {
    error = TRUE;
    sprintf(tmp, "Number of bands - Value (%i) outside the "
	    "expected value range (value > 0)\n", nValue);
    strcat(errorMessage, tmp);
  }
  else {
    data->band_count =
      xml_get_int_value(doc, "metadata.idinfo.bandidnt.numbands");
    //printf("Number of bands: %i\n", data->band_count);
  }

  // Browse image location
  strcpy(string, xml_get_string_value(doc, "metadata.idinfo.browse.browsen"));
  if (strlen(string) > MAX_BROWSE_LOCATION) {
    error = TRUE;
    sprintf(tmp, "Browse image location - String length: %d, allowed "
	    "characters: %d\n", (int) strlen(string), MAX_BROWSE_LOCATION);
    strcat(errorMessage, tmp);
  }
  else if (strcmp_case(string, MAGIC_UNSET_STRING) != 0) {
    data->browse_location = (char *) MALLOC(sizeof(char)*MAX_BROWSE_LOCATION);
    strcpy(data->browse_location, xml_get_string_value(doc, 
      "metadata.idinfo.browse.browsen"));
    //printf("Browse image location: %s\n", data->browse_location);
  }

  // Browse image format
  strcpy(string, xml_get_string_value(doc, "metadata.idinfo.browse.browset"));
  if (strlen(string) > MAX_BROWSE_FORMAT) {
    error = TRUE;
    sprintf(tmp, "Browse image format - String length: %d, allowed characters:"
	    " %d\n", (int) strlen(string), MAX_BROWSE_FORMAT);
    strcat(errorMessage, tmp);
  }
  else if (strcmp_case(string, MAGIC_UNSET_STRING) != 0) {
    data->browse_format = (char *) MALLOC(sizeof(char)*MAX_BROWSE_FORMAT);
    strcpy(data->browse_format, xml_get_string_value(doc, 
      "metadata.idinfo.browse.browset"));
    //printf("Browse format: %s\n", data->browse_format);
  }

  // Data access level
  strcpy(string, xml_get_string_value(doc, 
    "metadata.idinfo.secinfo.secclass"));
  if (strlen(string) > MAX_ACCESS) {
    error = TRUE;
    sprintf(tmp, "Data access level - String length: %d, allowed characters: "
	    "%d\n", (int) strlen(string), MAX_ACCESS);
    strcat(errorMessage, tmp);
  }
  else {
    strcpy(data->access, xml_get_string_value(doc, 
      "metadata.idinfo.secinfo.secclass"));
    //printf("Data access level: %s\n", data->access);
  }

  // Copyright
  strcpy(string, xml_get_string_value(doc, "metadata.idinfo.copyright"));
  if (strlen(string) > MAX_COPYRIGHT) {
    error = TRUE;
    sprintf(tmp, "Copyright - String length: %d, allowed characters: %d\n",
	    (int) strlen(string), MAX_COPYRIGHT);
    strcat(errorMessage, tmp);
  }
  else {
    strcpy(data->copyright, xml_get_string_value(doc, 
      "metadata.idinfo.copyright"));
    //printf("Copyright: %s\n", data->copyright);
  }

  // Start time
  char dateStr[25], timeStr[25], *message;
  int year, month, day, hour, minute, second;
  strcpy(dateStr, xml_get_string_value(doc, 
    "metadata.idinfo.timeperd.timeinfo.rngdates.begdate"));
  year = subStr(0, 4, dateStr);
  month = subStr(4, 2, dateStr);
  day = subStr(6, 2, dateStr);
  strcpy(timeStr, xml_get_string_value(doc, 
    "metadata.idinfo.timeperd.timeinfo.rngdates.begtime"));
  hour = subStr(0, 2, timeStr);
  minute = subStr(2, 2, timeStr);
  second = subStr(4, 2, timeStr);
  if (strcmp_case(dateStr, MAGIC_UNSET_STRING) != 0 &&
      strcmp_case(timeStr, MAGIC_UNSET_STRING) != 0) {
    if (isNumeric(dateStr) && isNumeric(timeStr)) {
      message = checkTime(year, month, day, hour, minute, second);
      if (message) {
	error = TRUE;
	sprintf(tmp, "Start time - %s", message);
	strcat(errorMessage, tmp);
      }
      else {
	data->start_time = (char *) MALLOC(sizeof(char)*MAX_START_TIME);
	sprintf(data->start_time, "%04d-%02d-%02d %02d:%02d:%02d", 
		year, month, day, hour, minute, second);
	//printf("Start time: %s\n", data->start_time);
      }
    }
  }

  // Center time
  strcpy(dateStr, xml_get_string_value(doc, 
    "metadata.idinfo.timeperd.timeinfo.sngdate.caldate"));
  year = subStr(0, 4, dateStr);
  month = subStr(4, 2, dateStr);
  day = subStr(6, 2, dateStr);
  strcpy(timeStr, xml_get_string_value(doc, 
    "metadata.idinfo.timeperd.timeinfo.sngdate.time"));
  hour = subStr(0, 2, timeStr);
  minute = subStr(2, 2, timeStr);
  second = subStr(4, 2, timeStr);
  if (strcmp_case(dateStr, MAGIC_UNSET_STRING) != 0 &&
      strcmp_case(timeStr, MAGIC_UNSET_STRING) != 0) {
    if (isNumeric(dateStr) && isNumeric(timeStr)) {
      message = checkTime(year, month, day, hour, minute, second);
      if (message) {
	error = TRUE;
	sprintf(tmp, "Center time - %s", message);
	strcat(errorMessage, tmp);
      }
      else {
	data->center_time = (char *) MALLOC(sizeof(char)*MAX_CENTER_TIME);
	sprintf(data->center_time, "%04d-%02d-%02d %02d:%02d:%02d", 
		year, month, day, hour, minute, second);
	//printf("Center time: %s\n", data->center_time);
      }
    }
  }

  // End time
  strcpy(dateStr, xml_get_string_value(doc, 
    "metadata.idinfo.timeperd.timeinfo.rngdates.enddate"));
  year = subStr(0, 4, dateStr);
  month = subStr(4, 2, dateStr);
  day = subStr(6, 2, dateStr);
  strcpy(timeStr, xml_get_string_value(doc, 
    "metadata.idinfo.timeperd.timeinfo.rngdates.endtime"));
  hour = subStr(0, 2, timeStr);
  minute = subStr(2, 2, timeStr);
  second = subStr(4, 2, timeStr);
  if (strcmp_case(dateStr, MAGIC_UNSET_STRING) != 0 &&
      strcmp_case(timeStr, MAGIC_UNSET_STRING) != 0) {
    if (isNumeric(dateStr) && isNumeric(timeStr)) {
      message = checkTime(year, month, day, hour, minute, second);
      if (message) {
	error = TRUE;
	sprintf(tmp, "End time - %s", message);
	strcat(errorMessage, tmp);
      }
      else {
	data->end_time = (char *) MALLOC(sizeof(char)*MAX_END_TIME);
	sprintf(data->end_time, "%04d-%02d-%02d %02d:%02d:%02d", 
		year, month, day, hour, minute, second);
	//printf("End time: %s\n", data->end_time);
      }
    }
  }

  // Orbit direction
  nValue = xml_get_int_value(doc, "metadata.dataqual.acqinfo.ascdscin");
  if (nValue != MAGIC_UNSET_INT) {
    if (nValue < 0 || nValue > 1) {
      error = TRUE;
      sprintf(tmp, "Orbit direction - Value (%i) outside the "
	      "expected value range (0 <= value <= 1)\n", nValue);
      strcat(errorMessage, tmp);
    }
    else {
      if (nValue == 0)
	strcpy(data->orbit_direction, "Ascending");
      else if (nValue == 1)
	strcpy(data->orbit_direction, "Descending");
      //printf("Orbit direction: %s\n", data->orbit_direction);
    }
  }
  else
    strcpy(data->orbit_direction, "Unknown");

  // Imaging mode
  strcpy(string, xml_get_string_value(doc, "metadata.idinfo.plainsid.mode"));
  if (strcmp_case(string, MAGIC_UNSET_STRING) != 0) {
    if (strlen(string) > MAX_MODE) {
      error = TRUE;
      sprintf(tmp, "Imaging mode - String length: %d, allowed characters: %d"
	      "\n", (int) strlen(string), MAX_MODE);
      strcat(errorMessage, tmp);
    }
    else {
      strcpy(data->mode, 
	     xml_get_string_value(doc, "metadata.idinfo.plainsid.mode"));
      //printf("Imaging mode: %s\n", data->mode);
    }
  }
  else
    strcpy(data->mode, "Unknown");

  // Spatial reference
  strcpy(string, xml_get_string_value(doc, "metadata.spdoinfo.direct"));
  if (strcmp_case(string, "Point") !=  0 &&
      strcmp_case(string, "Vector") != 0 &&
      strcmp_case(string, "Raster") != 0) {
    error = TRUE;
    sprintf(tmp, "Spatial reference - String (%s) not valid; expected "
	    "\"Point\", \"Vector\" or \"Raster\"\n", string);
    strcat(errorMessage, tmp);
  }
  else {
    strcpy(data->spatial_reference, 
	   xml_get_string_value(doc, "metadata.spdoinfo.direct"));
    //printf("Spatial reference: %s\n", data->spatial_reference);
  }

  // Cell value type
  strcpy(string, xml_get_string_value(doc, 
    "metadata.spdoinfo.rastinfo.cvaltype"));
  if (strlen(string) > MAX_CELL_VALUE) {
    error = TRUE;
    sprintf(tmp, 
	    "Cell value type - String length: %d, allowed characters: %d\n",
	    (int) strlen(string), MAX_CELL_VALUE);
    strcat(errorMessage, tmp);
  }
  else {
    strcpy(data->cell_value, xml_get_string_value(doc, 
      "metadata.spdoinfo.rastinfo.cvaltype"));
    //printf("Cell value type: %s\n", data->cell_value);
  }

  // Raster object type
  strcpy(string, xml_get_string_value(doc, 
    "metadata.spdoinfo.rastinfo.rasttype"));
  if (strcmp_case(string, "Point") != 0 &&
      strcmp_case(string, "Pixel") != 0 &&
      strcmp_case(string, "Grid Cell") != 0 &&
      strcmp_case(string, "Voxel") != 0 &&
      strcmp_case(string, "Swath") != 0) {
    error = TRUE;
    sprintf(tmp, "Raster object type - String (%s) not valid; expected "
	    "\"Point\", \"Pixel\", \"Grid Cell\", \"Voxel\" or \"Swath\".\n",
	    string);
    strcat(errorMessage, tmp);
  }
  else {
    strcpy(data->raster_object, xml_get_string_value(doc, 
      "metadata.spdoinfo.rastinfo.rasttype"));
    //printf("Raster object type: %s\n", data->raster_object);
  }

  // Number of rows
  nValue = xml_get_int_value(doc, "metadata.spdoinfo.rastinfo.rowcount");
  if (nValue < 0) {
    error = TRUE;
    sprintf(tmp, "Number of rows - Value (%i) outside the "
	    "expected value range (value > 0)\n", nValue);
    strcat(errorMessage, tmp);
  }
  else {
    data->row_count =
      xml_get_int_value(doc, "metadata.spdoinfo.rastinfo.rowcount");
    //printf("Number of rows: %i\n", data->row_count);
  }

  // Number of columns
  nValue = xml_get_int_value(doc, "metadata.spdoinfo.rastinfo.colcount");
  if (nValue < 0) {
    error = TRUE;
    sprintf(tmp, "Number of columns - Value (%i) outside the "
	    "expected value range (value > 0)\n", nValue);
    strcat(errorMessage, tmp);
  }
  else {
    data->col_count =
      xml_get_int_value(doc, "metadata.spdoinfo.rastinfo.colcount");
    //printf("Number of columns: %i\n", data->col_count);
  }

  // Format name
  strcpy(string, xml_get_string_value(doc, 
    "metadata.distinfo.stdorder.digform.digtinfo.formname"));
  if (strlen(string) > MAX_FORMAT) {
    error = TRUE;
    sprintf(tmp, 
	    "Format name - String length: %d, allowed characters: %d\n",
	    (int) strlen(string), MAX_FORMAT);
    strcat(errorMessage, tmp);
  }
  else {
    strcpy(data->format, xml_get_string_value(doc, 
      "metadata.distinfo.stdorder.digform.digtinfo.formname"));
    //printf("Format name: %s\n", data->format);
  }

  // Fees
  fValue = xml_get_double_value(doc, "metadata.distinfo.stdorder.fees");
  if (fValue < 0.0) {
    error = TRUE;
    sprintf(tmp, "Fees - Value (%.2lf) outside the expected value range "
	    "(value >= 0.0)\n", fValue);
    strcat(errorMessage, tmp);
  }
  else {
    data->fees = xml_get_double_value(doc, "metadata.distinfo.stdorder.fees");
    //printf("Fees: %.2lf\n", data->fees);
  }

  if (error)
    asfPrintError("%s", errorMessage);

  xmlFreeDoc(doc);
  xmlCleanupParser();

  FREE(configFile);
  FCLOSE(fLog);
  remove(logFile);

  // Add dataset to database
  addData(data);

  FREE(data);

  asfPrintStatus("\nSuccessful completion!\n\n");

  return(EXIT_SUCCESS);
}
Exemplo n.º 25
0
void M_LoadDefaults (void)
{
  int   i;
  int   len;
  FILE* f;
  char  def[80];
  char  strparm[100];
  char* newstring = NULL;   // killough
  int   parm;
  boolean isstring;

  // set everything to base values

  numdefaults = sizeof(defaults) / sizeof(defaults[0]);
  for (i = 0 ; i < numdefaults ; i++) {
    if (defaults[i].location.ppsz)
      *defaults[i].location.ppsz = strdup(defaults[i].defaultvalue.psz);
    if (defaults[i].location.pi)
      *defaults[i].location.pi = defaults[i].defaultvalue.i;
  }

  // check for a custom default file

#if ((defined GL_DOOM) && (defined _MSC_VER))
#define BOOM_CFG "glboom.cfg"
#else
#define BOOM_CFG "prboom.cfg"
#endif

  i = M_CheckParm ("-config");
  if (i && i < myargc-1)
    defaultfile = strdup(myargv[i+1]);
  else {
    const char* exedir = I_DoomExeDir();
    /* get config file from same directory as executable */
#if 1
	int len = doom_snprintf(NULL, 0, BOOM_CFG);
	defaultfile = malloc(len+1);
	doom_snprintf(defaultfile, len+1, BOOM_CFG);
#else
    int len = doom_snprintf(NULL, 0, "%s/" BOOM_CFG, exedir);
    defaultfile = malloc(len+1);
    doom_snprintf(defaultfile, len+1, "%s/" BOOM_CFG, exedir);
#endif
  }

  lprintf (LO_CONFIRM, " default file: %s\n",defaultfile);

  // read the file in, overriding any set defaults

  f = fopen (defaultfile, "r");
  if (f)
    {
    while (!feof(f))
      {
      isstring = false;
      if (fscanf (f, "%79s %[^\n]\n", def, strparm) == 2)
        {

        //jff 3/3/98 skip lines not starting with an alphanum

        if (!isalnum(def[0]))
          continue;

        if (strparm[0] == '"') {
          // get a string default

          isstring = true;
          len = strlen(strparm);
          newstring = (char *) malloc(len);
          strparm[len-1] = 0; // clears trailing double-quote mark
          strcpy(newstring, strparm+1); // clears leading double-quote mark
  } else if ((strparm[0] == '0') && (strparm[1] == 'x')) {
    // CPhipps - allow ints to be specified in hex
    sscanf(strparm+2, "%x", &parm);
  } else {
          sscanf(strparm, "%i", &parm);
    // Keycode hack removed
  }

        for (i = 0 ; i < numdefaults ; i++)
          if ((defaults[i].type != def_none) && !strcmp(def, defaults[i].name))
            {
      // CPhipps - safety check
            if (isstring != IS_STRING(defaults[i])) {
        lprintf(LO_WARN, "M_LoadDefaults: Type mismatch reading %s\n", defaults[i].name);
        continue;
      }
            if (!isstring)
              {

              //jff 3/4/98 range check numeric parameters

              if ((defaults[i].minvalue==UL || defaults[i].minvalue<=parm) &&
                  (defaults[i].maxvalue==UL || defaults[i].maxvalue>=parm))
                *(defaults[i].location.pi) = parm;
              }
            else
              {
                union { const char **c; char **s; } u; // type punning via unions

                u.c = defaults[i].location.ppsz;
                free(*(u.s));
                *(u.s) = newstring;
              }
            break;
            }
        }
      }

    fclose (f);
    }
  //jff 3/4/98 redundant range checks for hud deleted here
}
Exemplo n.º 26
0
void gw_dm_listener(void *arg)
{
    fd_set  in_pipes;
    int     i, j,num_mads;
    int     greater, rc, rcm;
    char    c;
    char    info[GW_DM_MAX_INFO];
    char    s_id[GW_DM_MAX_ID];
    char    result[GW_DM_MAX_RESULT];
    char    action[GW_DM_MAX_ACTION];
    char    str[GW_DM_MAX_STRING];
    char    *s_host_id, *queue_name, *s_rank, *lasts;
    int     job_id, host_id, rank;
    gw_dm_mad_t * dm_mad;
    
    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); 
    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
    
    while (1)
    {
        greater = gw_dm_set_pipes (&in_pipes, &num_mads);
                
        select( greater+1, &in_pipes, NULL, NULL, NULL);

        for (i= 0; i<=greater; i++) 
        {
            if ( FD_ISSET(i, &in_pipes) )
            {                
                dm_mad = gw_dm_get_mad_by_fd(i);
                
                if ( dm_mad == NULL )
                    continue;

                j = 0;

                do
                {
                    rc = read(i, (void *) &c, sizeof(char));
                    str[j++] = c;    
                }                
                while ((rc > 0) && (c != '\n') && (j < (GW_DM_MAX_STRING-1)));

				str[j] = '\0';    

                if (rc <= 0) /* Error Reading message from MAD! */
                {
                    gw_log_print("DM",'W',"Error reading MAD (%s) message\n",
                            dm_mad->name);
                    
                    pthread_mutex_lock(&(gw_dm.mutex));
                    
                    gw_dm.scheduling = GW_TRUE; /* Prevents to call the scheduler while recovering*/
                    
                    pthread_mutex_unlock(&(gw_dm.mutex));                    
                    
                    rcm = gw_dm_mad_reload(dm_mad);
                    
                    if ( rcm == 0 )
                    {
                        gw_log_print("DM",'I',"MAD (%s) successfully reloaded\n",
                            dm_mad->name);
                        
                        gw_user_pool_dm_recover(dm_mad);
                        
                        gw_host_pool_dm_recover(dm_mad);
                        
                        gw_job_pool_dm_recover(dm_mad);
                    }
                    else
                    {
                        gw_log_print("DM",'E',"Error reloading the scheduler (%s)\n",
                            dm_mad->name);
                            
                        dm_mad->mad_dm_pipe = -1;
                        
                        if ( num_mads == 1 )
                        {
                            gw_log_print("DM",'E',"GridWay needs to be restarted! (no scheduler)\n");
                            
                            return;
                        }
                    }
                    
                    pthread_mutex_lock(&(gw_dm.mutex));
                    
                    gw_dm.scheduling = GW_FALSE; /* Activate the scheduler again*/
                    
                    pthread_mutex_unlock(&(gw_dm.mutex));                    
                    
                    continue;
                }
                
                info[0] = '\0';

                sscanf(str,"%" GW2STR(GW_DM_MAX_ACTION) "s %"
                       GW2STR(GW_DM_MAX_ID) "s %"
                       GW2STR(GW_DM_MAX_RESULT) "s %"
                       GW2STR(GW_DM_MAX_INFO) "[^\n]", 
                       action, 
                       s_id, 
                       result, 
                       info);
  
#ifdef GWDMDEBUG
                gw_log_print("DM",'D',"MAD (%s) message %s %s %s %s (info length=%d).\n",
                        dm_mad->name, 
                        action, 
                        s_id, 
                        result,
                        info, 
                        strlen(info));
#endif
                if (strcmp(action, "SCHEDULE_JOB") == 0)
                {
                    if (strcmp(result, "SUCCESS") == 0)
                    {
                        job_id     = atoi(s_id);
                        s_host_id  = strtok_r(info, ":", &lasts);
                        queue_name = strtok_r(NULL, ":", &lasts);
                        s_rank     = lasts;
                        
                        if (s_host_id == NULL || queue_name == NULL || s_rank == NULL)
                        {
                            gw_log_print("DM",'E',"Bad resource specification (%s) from scheduler.\n",
                                         info);
                            continue;
                        }

                        host_id = atoi(s_host_id);
                        rank    = atoi(s_rank);
                        
                        gw_dm_dispatch_job(job_id, host_id, queue_name, rank);
                    }
                    else
                    {
                        gw_log_print("DM",'E',"Can't schedule job %s: %s.\n", s_id, info);

                        job_id = atoi(s_id);
                        
                        gw_dm_uncheck_job(job_id);
                    }
                }
                else if (strcmp(action, "SCHEDULE_END") == 0)
                {
                	pthread_mutex_lock(&(gw_dm.mutex));
                	
                	gw_dm.scheduling = GW_FALSE;
                	
                	pthread_mutex_unlock(&(gw_dm.mutex));	
                }
                else
                {
                    gw_log_print("DM",'E',"Unknown MAD action %s.\n", action);
                }
            }
        }    
    }
}
Exemplo n.º 27
0
/*
 * The data returned by the following routine is always in left-most byte
 * first and left-most bit first.  If it doesn't return BitmapSuccess then
 * its arguments won't have been touched.  This routine should look as much
 * like the Xlib routine XReadBitmapfile as possible.
 */
int XmuReadBitmapData (
    FILE *fstream,			/* handle on file  */
    unsigned int *width,		/* RETURNED */
    unsigned int *height,		/* RETURNED */
    unsigned char **datap,		/* RETURNED */
    int *x_hot, int *y_hot)		/* RETURNED */
{
    unsigned char *data = NULL;		/* working variable */
    char line[MAX_SIZE];		/* input line from file */
    int size;				/* number of bytes of data */
    char name_and_type[MAX_SIZE];	/* an input line */
    char *type;				/* for parsing */
    int value;				/* from an input line */
    int version10p;			/* boolean, old format */
    int padding;			/* to handle alignment */
    int bytes_per_line;			/* per scanline of data */
    unsigned int ww = 0;		/* width */
    unsigned int hh = 0;		/* height */
    int hx = -1;			/* x hotspot */
    int hy = -1;			/* y hotspot */

#ifndef Xmalloc
#define Xmalloc(size) malloc(size)
#endif

    /* first time initialization */
    if (!hex_initialized) initHexTable();

    /* error cleanup and return macro	*/
#define	RETURN(code) { if (data) free (data); return code; }

    while (fgets(line, MAX_SIZE, fstream)) {
	if (strlen(line) == MAX_SIZE-1) {
	    RETURN (BitmapFileInvalid);
	}
	if (sscanf(line,"#define %s %d",name_and_type,&value) == 2) {
	    if (!(type = strrchr(name_and_type, '_')))
	      type = name_and_type;
	    else
	      type++;

	    if (!strcmp("width", type))
	      ww = (unsigned int) value;
	    if (!strcmp("height", type))
	      hh = (unsigned int) value;
	    if (!strcmp("hot", type)) {
		if (type-- == name_and_type || type-- == name_and_type)
		  continue;
		if (!strcmp("x_hot", type))
		  hx = value;
		if (!strcmp("y_hot", type))
		  hy = value;
	    }
	    continue;
	}

	if (sscanf(line, "static short %s = {", name_and_type) == 1)
	  version10p = 1;
	else if (sscanf(line,"static unsigned char %s = {",name_and_type) == 1)
	  version10p = 0;
	else if (sscanf(line, "static char %s = {", name_and_type) == 1)
	  version10p = 0;
	else
	  continue;

	if (!(type = strrchr(name_and_type, '_')))
	  type = name_and_type;
	else
	  type++;

	if (strcmp("bits[]", type))
	  continue;

	if (!ww || !hh)
	  RETURN (BitmapFileInvalid);

	if ((ww % 16) && ((ww % 16) < 9) && version10p)
	  padding = 1;
	else
	  padding = 0;

	bytes_per_line = (ww+7)/8 + padding;

	size = bytes_per_line * hh;
	data = (unsigned char *) Xmalloc ((unsigned int) size);
	if (!data)
	  RETURN (BitmapNoMemory);

	if (version10p) {
	    unsigned char *ptr;
	    int bytes;

	    for (bytes=0, ptr=data; bytes<size; (bytes += 2)) {
		if ((value = NextInt(fstream)) < 0)
		  RETURN (BitmapFileInvalid);
		*(ptr++) = value;
		if (!padding || ((bytes+2) % bytes_per_line))
		  *(ptr++) = value >> 8;
	    }
	} else {
	    unsigned char *ptr;
	    int bytes;

	    for (bytes=0, ptr=data; bytes<size; bytes++, ptr++) {
		if ((value = NextInt(fstream)) < 0)
		  RETURN (BitmapFileInvalid);
		*ptr=value;
	    }
	}
	break;
    }					/* end while */
Exemplo n.º 28
0
static Image *ReadXTRNImage(const ImageInfo *image_info,
                            ExceptionInfo *exception)
{
    Image
    *image;

    ImageInfo
    *clone_info;

    void
    *param1,
    *param2,
    *param3;

    param1 = param2 = param3 = (void *) NULL;
    image = (Image *) NULL;
    clone_info=CloneImageInfo(image_info);
    if (clone_info->filename == NULL)
    {
        clone_info=DestroyImageInfo(clone_info);
        ThrowReaderException(FileOpenWarning,"No filename specified");
    }
    if (LocaleCompare(image_info->magick,"XTRNFILE") == 0)
    {
        image=ReadImage(clone_info,exception);
        CatchException(exception);
    }
    else if (LocaleCompare(image_info->magick,"XTRNIMAGE") == 0)
    {
        Image
        **image_ptr;

#ifdef ALL_IMAGEINFO
        ImageInfo
        **image_info_ptr;
#endif

        (void) sscanf(clone_info->filename,"%lx,%lx",&param1,&param2);
        image_ptr=(Image **) param2;
        if (*image_ptr != (Image *) NULL)
            image=CloneImage(*image_ptr,0,0,MagickFalse,exception);
#ifdef ALL_IMAGEINFO
        image_info_ptr=(ImageInfo **) param1;
        if (*image_info_ptr != (ImageInfo *) NULL)
            image_info=*image_info_ptr;
#endif
    }
    else if (LocaleCompare(image_info->magick,"XTRNBLOB") == 0)
    {
        char
        **blob_data;

        size_t
        *blob_length;

        char
        filename[MagickPathExtent];

        (void) sscanf(clone_info->filename,"%lx,%lx,%2048s",&param1,&param2,
                      filename);
        blob_data=(char **) param1;
        blob_length=(size_t *) param2;
        image=BlobToImage(clone_info,*blob_data,*blob_length,exception);
        CatchException(exception);
    }
    else if (LocaleCompare(image_info->magick,"XTRNARRAY") == 0)
    {
        char
        *blob_data,
        filename[MagickPathExtent];

        HRESULT
        hr;

        long
        lBoundl,
        lBoundu;

        SAFEARRAY
        *pSafeArray;

        size_t
        blob_length;

        *filename='\0';
        (void) sscanf(clone_info->filename,"%lx,%2048s",&param1,filename);
        hr=S_OK;
        pSafeArray=(SAFEARRAY *) param1;
        if (pSafeArray)
        {
            hr = SafeArrayGetLBound(pSafeArray, 1, &lBoundl);
            if (SUCCEEDED(hr))
            {
                hr = SafeArrayGetUBound(pSafeArray, 1, &lBoundu);
                if (SUCCEEDED(hr))
                {
                    blob_length = lBoundu - lBoundl + 1;
                    hr = SafeArrayAccessData(pSafeArray,(void**) &blob_data);
                    if(SUCCEEDED(hr))
                    {
                        *clone_info->filename='\0';
                        *clone_info->magick='\0';
                        if (*filename != '\0')
                            (void) CopyMagickString(clone_info->filename,filename,
                                                    MagickPathExtent);
                        image=BlobToImage(clone_info,blob_data,blob_length,
                                          exception);
                        hr=SafeArrayUnaccessData(pSafeArray);
                        CatchException(exception);
                    }
                }
            }
        }
    }
    clone_info=DestroyImageInfo(clone_info);
    return(image);
}
Exemplo n.º 29
0
unsigned int get_pid_by_name(const char *pro_name)
{
	/*
	 * search /proc/pid/status to find program's name 
	 * and then we can find the pid
	 */
	unsigned int pid = 1; // search start
	FILE *filp = NULL;
	char proc_status[20] = {0};
	char status_info[100] = {0}; //file status information store in this
	char cur_name[100] = {0}; //program's name's max lenght

	unsigned int pid_max = get_sys_max_pid(); //max pid

	while (1) {
		/*
		 * open 1 program's status file, then read data
		 */
		sprintf(proc_status, "/proc/%u/status", pid);
#ifdef DEBUG
		printf("proc_status: %s, led: %d\n", proc_status, strlen(proc_status));
#endif

		filp = fopen(proc_status, "r");
		if (!filp) {
#ifdef DEBUG
			perror("fopen");
#endif
			if (pid >= pid_max) {
				fprintf(stderr, "Can not find pid of program %s\n", pro_name);
				break;
			}
			/*
			 * current pid is no exist, go to search next
			 */
			pid++;
			continue;
		} 
		/*
		 * get one line to sparse by loop
		 */
		while ((!feof(filp)) && (fgets(status_info, 99, filp))) {
			if (sscanf(status_info, "Name: %s", cur_name) == 1) {
				/*
				 * Run here means that we got current program's name,
				 * next what we should do is to compare.
				 */
				if (!strcmp(cur_name, pro_name)) {
					fclose(filp);
					return pid;
				}
				/*
				 * Not match, search next pid.
				 */
				bzero(cur_name, sizeof(cur_name));
				break;

			}
			/*
			 * Didn't scan target, scan next line.
			 */
			bzero(status_info, sizeof(status_info));
		} /* end of one pid */
		pid++;
		fclose(filp);
		bzero(status_info, sizeof(status_info));
	}
	
	return 0; /* Haven't find the pid, return 0 */
}
Exemplo n.º 30
0
/* Breakpoint command */
int		cmd_bp()
{
  char		*str;
  int		ret;
  eresi_Addr	addr;
  char		logbuf[BUFSIZ];
  int		idx;
  int		index;
  elfsh_SAddr	off = 0;
  char		*name;
  elfshbp_t	*cur;
  char		**keys;
  int		keynbr;

  PROFILER_IN(__FILE__, __FUNCTION__, __LINE__);

  /* build argc */
  for (idx = 0; world.curjob->curcmd->param[idx] != NULL; idx++);
  str = revm_lookup_string(world.curjob->curcmd->param[0]);

  /* Select subcommand */
  switch (idx)
    {
      
      /* List breakpoints */
      case 0:
	e2dbg_output(" .:: Breakpoints ::.\n\n");	      
	keys = hash_get_keys(&e2dbgworld.bp, &keynbr);
	for (index = 0; index < keynbr; index++)
	  {
	    cur = hash_get(&e2dbgworld.bp, keys[index]);
	    name = revm_resolve(world.curjob->curfile, 
				(eresi_Addr) cur->addr, &off);
	    if (off)
	      snprintf(logbuf, BUFSIZ, " %c [%02u] " XFMT " <%s + " UFMT ">\n", 
		       (e2dbg_is_watchpoint(cur) ? 'W' : 'B'),
		       cur->id, cur->addr, name, off);
	    else
	      snprintf(logbuf, BUFSIZ, " %c [%02u] " XFMT " <%s>\n", 
		       (e2dbg_is_watchpoint(cur) ? 'W' : 'B'),
		       cur->id, cur->addr, name);
	    e2dbg_output(logbuf);
	  }
	hash_free_keys(keys);
	if (!index)
	  e2dbg_output(" [*] No breakpoints\n");
	e2dbg_output("\n");
	break;
      
	/* Supply a new breakpoint */
      case 1:
	if (!elfsh_is_runtime_mode())
	  PROFILER_ERR(__FILE__, __FUNCTION__, __LINE__,
		       "Not in dynamic or debugger mode", -1);
	if (!str || !(*str))
	  PROFILER_ERR(__FILE__, __FUNCTION__, __LINE__, 
		       "Invalid argument", -1);
      
	/* Break on a supplied virtual address */
	if (IS_VADDR(str))
	  {
	    if (sscanf(str + 2, AFMT, &addr) != 1)
	      PROFILER_ERR(__FILE__, __FUNCTION__, __LINE__, 
			   "Invalid virtual address requested", (-1));
	  }
      
	/* Resolve first a function name */
	else
	  {
	    addr = e2dbg_breakpoint_find_addr(str);
	    if (addr == 0)
	      PROFILER_ERR(__FILE__, __FUNCTION__, __LINE__, 
			   "Requested symbol address unknown", -1);
	  }
      
	/* Add the breakpoint */
	ret = e2dbg_breakpoint_add(addr);
	if (ret < 0)
	  PROFILER_ERR(__FILE__, __FUNCTION__, __LINE__, 
		       "Breakpoint insertion failed\n", (-1));
	if (ret >= 0)
	  {
	    name = revm_resolve(world.curjob->curfile, addr, &off);
	    if (!off)
	      snprintf(logbuf, BUFSIZ - 1, 
		       " [*] Breakpoint added at <%s> (" XFMT ")\n\n", name, addr);
	    else
	      snprintf(logbuf, BUFSIZ - 1, 
		       " [*] Breakpoint added at <%s + " UFMT "> (" XFMT ")\n\n", 
		       name, off, addr);
	    e2dbg_output(logbuf);
	  }
	break;

	/* Wrong command syntax */
      default:
	PROFILER_ERR(__FILE__, __FUNCTION__, __LINE__, 
		     "Wrong arg number", (-1));
    }

  PROFILER_ROUT(__FILE__, __FUNCTION__, __LINE__, (ret));
}