static void
parse_time_string(unsigned int *hour, unsigned int *minute, const char *time)
{
	char *hours;
	char *minutes;

	hours = (char *)malloc(3);
	minutes = (char *)malloc(3);
	bzero((void *)hours, 3);
	bzero((void *)minutes, 3);

	if (split_time(&hours, &minutes, time) == 1)
	{
                /* if the number starts with 0, replace it with a space else
                   this string_to_number will interpret it as octal !! */
                if ((hours[0] == '0') && (hours[1] != '\0'))
			hours[0] = ' ';
		if ((minutes[0] == '0') && (minutes[1] != '\0'))
			minutes[0] = ' ';

		if((string_to_number(hours, 0, 23, hour) == -1) ||
			(string_to_number(minutes, 0, 59, minute) == -1)) {
			*hour = *minute = (-1);
		}
	}
	if ((*hour != (-1)) && (*minute != (-1))) {
		free(hours);
		free(minutes);
		return;
	}

	/* If we are here, there was a problem ..*/
	print_error("invalid time %s specified, should be HH:MM format", time);
}
Exemplo n.º 2
0
static PyObject *NumberValue(PyObject *self, PyObject *args)
{
  PyObject *object;
  PyObject *result = NULL;

  if (!PyArg_ParseTuple(args, "O:NumberValue", &object))
    return NULL;
  
  result = PyNumber_Float(object);
  if (result)
    return result;

  PyErr_Clear();

  if (PyString_Check(object) || PyUnicode_Check(object))
    return string_to_number(object);

  /* convert it to a string */
  object = object_to_string(object);
  if (object) {
    result = string_to_number(object);
    Py_DECREF(object);
  }
  else result = NULL;

  return result;
}
Exemplo n.º 3
0
int main()
{
    number_t a, b, c;
    int i;

    a = string_to_number("-1.7171");
    b = string_to_number("-17.17");
    c = zero();

    print_number(a);
    printf("\n");
    print_number(b);
    printf("\n");
    c = sub_number(a, b);
    /*
       for(i=-10; i<10; i++) {
       c = make_exp(i);
       print_number(c);
       printf("\n");
       }
       */

    c = mult_num(a, b);
    print_number(c);
    printf("\n");

    return 0;
}
Exemplo n.º 4
0
Arquivo: m_ipt.c Projeto: NieHao/R7000
struct in_addr *dotted_to_addr(const char *dotted)
{
	static struct in_addr addr;
	unsigned char *addrp;
	char *p, *q;
	unsigned int onebyte;
	int i;
	char buf[20];

	/* copy dotted string, because we need to modify it */
	strncpy(buf, dotted, sizeof (buf) - 1);
	addrp = (unsigned char *) &(addr.s_addr);

	p = buf;
	for (i = 0; i < 3; i++) {
		if ((q = strchr(p, '.')) == NULL)
			return (struct in_addr *) NULL;

		*q = '\0';
		if (string_to_number(p, 0, 255, &onebyte) == -1)
			return (struct in_addr *) NULL;

		addrp[i] = (unsigned char) onebyte;
		p = q + 1;
	}

	/* we've checked 3 bytes, now we check the last one */
	if (string_to_number(p, 0, 255, &onebyte) == -1)
		return (struct in_addr *) NULL;

	addrp[3] = (unsigned char) onebyte;

	return &addr;
}
Exemplo n.º 5
0
//==============================================================================
static void read_range(const String& input, BoolVector& range,
		uint_t min_value, uint_t max_value)
{
	boost::cmatch what;
	boost::regex exp("(\\d{1,})-(\\d{1,})");

	StringVector list;
	boost::split(list, input, boost::is_any_of(","));

	foreach(const String& item, list)
	{
		uint_t n = 0;
		uint_t r1, r2;
		if (string_to_number(item, n))
			r1 = r2 = n;
		else
		{
			if (!boost::regex_match(item.c_str(), what, exp))
				throw std::runtime_error("read_range: incorrect input");
			string_to_number(what[1].str(), r1);
			string_to_number(what[2].str(), r2);
			if (r1 > r2)
				std::swap(r1, r2);
		}
		if (r2 > max_value || r1 < min_value)
			throw std::runtime_error("read_range: value is out of range");

		if (range.size() <= r2)
			range.resize(r2 + 1, false);
		for (; r1 <= r2; r1++)
			range[r1] = true;
	}
Exemplo n.º 6
0
// Dumps memory.
void command_dump(int number_of_arguments, char **argument)
{
    int length;
    int base;

    if (number_of_arguments != 2 &&
        number_of_arguments != 3)
    {
        debug_print("Invalid number of arguments. Try 'help %s'.\n", argument[0]);

        return;
    }

    string_to_number(argument[1], &base);

    if (number_of_arguments == 3)
    {
        string_to_number(argument[2], &length);
    }
    else
    {
        length = 1;
    }

    debug_print("%u %s\n", length, argument[2]);
    debug_memory_dump((void *) base, length);
}
Exemplo n.º 7
0
static int parse(int c, char **argv, int invert, unsigned int *flags,
		const struct ipt_entry *entry, unsigned int *nfcache,
		struct ipt_entry_match **match)
{
	struct ipt_ttl_info *info = (struct ipt_ttl_info *) (*match)->data;
	unsigned int value;

	check_inverse(optarg, &invert, &optind, 0);

	switch (c) {
		case '2':
			if (string_to_number(optarg, 0, 255, &value) == -1)
				exit_error(PARAMETER_PROBLEM,
				           "ttl: Expected value between 0 and 255");

			if (invert)
				info->mode = IPT_TTL_NE;
			else
				info->mode = IPT_TTL_EQ;

			/* is 0 allowed? */
			info->ttl = value;
			break;
		case '3':
			if (string_to_number(optarg, 0, 255, &value) == -1)
				exit_error(PARAMETER_PROBLEM,
				           "ttl: Expected value between 0 and 255");

			if (invert) 
				exit_error(PARAMETER_PROBLEM,
						"ttl: unexpected `!'");

			info->mode = IPT_TTL_LT;
			info->ttl = value;
			break;
		case '4':
			if (string_to_number(optarg, 0, 255, &value) == -1)
				exit_error(PARAMETER_PROBLEM,
				           "ttl: Expected value between 0 and 255");

			if (invert)
				exit_error(PARAMETER_PROBLEM,
						"ttl: unexpected `!'");

			info->mode = IPT_TTL_GT;
			info->ttl = value;
			break;
		default:
			return 0;

	}

	if (*flags) 
		exit_error(PARAMETER_PROBLEM, 
				"Can't specify TTL option twice");
	*flags = 1;

	return 1;
}
Exemplo n.º 8
0
//==============================================================================
static bool extract_usb_address(const String &str, uint_t &bus, uint_t &device)
{
	boost::cmatch what;
	boost::regex regex("([\\d]{1,3}):([\\d]{1,3})");

	if (!boost::regex_match(str.c_str(), what, regex))
		return false;

	string_to_number(what[1].str(), bus);
	string_to_number(what[2].str(), device);
	return true;
}
Exemplo n.º 9
0
int test2()
{
    char x[128], y[128];

    while(1) 
    {
        scanf("%s", x);
        scanf("%s", y);
        print_number(mult_number(string_to_number(x), string_to_number(y)));
        printf("\n");
    }
}
Exemplo n.º 10
0
int main (int argc, char **argv)
{
  if (argc < 2)
    usage ("Invalid number of arguments");

  {    
    const char *const action = argv[1];    
    Success (*function) (Stream, Connection_Id);
    Connection_Id conn_id;
    char *host;
    int port;

    if (! strcmp (action, "--version"))
      {
        printf ("spdsend %s\n", VERSION);
        exit (EXIT_OK);
      }
    
    if (! strcmp (action, "--open"))
      {
        if (argc != 4)
          usage ("Invalid number of arguments");
        host = argv[2];
        port = string_to_number (argv[3], 0, 65535);
      }
    else
      {
        if (argc != 3)
          usage ("Invalid number of arguments");
        conn_id = string_to_number (argv[2], CONNECTION_ID_MIN,
                                    CONNECTION_ID_MAX);
        if (! strcmp (action, "--close"))
          function = close_connection;
        else if (! strcmp (action, "--send"))
          function = send_command;
        else
          usage ("Invalid option");
      }
    
    {
      Stream server = open_server ();
      if (server == NONE)
        return EXIT_ERROR;
      
      {
        int result = (! strcmp (action, "--open")
                      ? open_connection (server, host, port)
                      : function (server, conn_id));
        return (result == OK ? EXIT_OK : EXIT_ERROR);
      }
    }
  }
}
Exemplo n.º 11
0
static int
parse(int c, char **argv, int invert, unsigned int *flags,
      const struct ip6t_entry *entry,
      unsigned int *nfcache,
      struct ip6t_entry_match **match)
{
	struct ip6t_fuzzy_info *fuzzyinfo =
		(struct ip6t_fuzzy_info *)(*match)->data;

	u_int32_t num;

	switch (c) {

	case '1':

	if (invert)
	       	exit_error(PARAMETER_PROBLEM,"Can't specify ! --lower-limit");

	if (*flags & IP6T_FUZZY_OPT_MINIMUM)
       	      exit_error(PARAMETER_PROBLEM,"Can't specify --lower-limit twice");

	if (string_to_number(optarg,1,MAXFUZZYRATE,&num) == -1 || num < 1)
			exit_error(PARAMETER_PROBLEM,"BAD --lower-limit");

		fuzzyinfo->minimum_rate = num ;

		*flags |= IP6T_FUZZY_OPT_MINIMUM;

		break;

	case '2':

	if (invert)
		exit_error(PARAMETER_PROBLEM,"Can't specify ! --upper-limit");

	if (*flags & IP6T_FUZZY_OPT_MAXIMUM)
	   exit_error(PARAMETER_PROBLEM,"Can't specify --upper-limit twice");

	if (string_to_number(optarg,1,MAXFUZZYRATE,&num) == -1 || num < 1)
		exit_error(PARAMETER_PROBLEM,"BAD --upper-limit");

		fuzzyinfo->maximum_rate = num;

		*flags |= IP6T_FUZZY_OPT_MAXIMUM;

		break ;

	default:
		return 0;
	}
	return 1;
}
Exemplo n.º 12
0
/* Function which parses command options; returns true if it ate an option */
static int
create_parse(int c, char *argv[], void *data, unsigned *flags)
{
	struct ip_set_req_nethash_create *mydata =
	    (struct ip_set_req_nethash_create *) data;
	ip_set_ip_t value;

	DP("create_parse");

	switch (c) {
	case '1':

		if (string_to_number(optarg, 1, UINT_MAX - 1, &mydata->hashsize))
			exit_error(PARAMETER_PROBLEM, "Invalid hashsize `%s' specified", optarg);

		*flags |= OPT_CREATE_HASHSIZE;

		DP("--hashsize %u", mydata->hashsize);
		
		break;

	case '2':

		if (string_to_number(optarg, 1, 65535, &value))
			exit_error(PARAMETER_PROBLEM, "Invalid probes `%s' specified", optarg);

		mydata->probes = value;
		*flags |= OPT_CREATE_PROBES;

		DP("--probes %u", mydata->probes);
		
		break;

	case '3':

		if (string_to_number(optarg, 0, 65535, &value))
			exit_error(PARAMETER_PROBLEM, "Invalid resize `%s' specified", optarg);

		mydata->resize = value;
		*flags |= OPT_CREATE_RESIZE;

		DP("--resize %u", mydata->resize);
		
		break;

	default:
		return 0;
	}

	return 1;
}
Exemplo n.º 13
0
Arquivo: parsing.c Projeto: 8l/eight
closure *parse_number(FILE *file, closure *accum)
{
    wchar_t c = fgetwc(file);
    if(iswdigit(c)){
	return parse_number(file, cons(character(c), accum));
    } else if(iswspace(c)) {
	return string_to_number(reverse(accum));
    } else if(c == L')') {
	ungetwc(c, file); 
	return string_to_number(reverse(accum));
    } else {
	ungetwc(c, file);
	return parse_symbol(file, accum);
    }
}
Exemplo n.º 14
0
number_t mult_number(number_t a, number_t b)
{
    number_t result;
    int i, k;

    result = string_to_number("0.0");
    for (i = 0; i < b.digit_len; i++) {
        result = mult_one(10, result);
        result = add_number(result, mult_one(b.digit[i], a));
    }

    k = b.digit_len - b.int_len;
    if (result.int_len > k) {
        result.int_len -= k;
    } else {
        for (i = result.digit_len - 1; i >= 0; i--)
            result.digit[i + k] = result.digit[i];
        for (i = 0; i < k; i++)
            result.digit[i] = 0;
        result.digit_len += k;	
    }

    result.sign *= b.sign;
    return remove_zeros(result);
}
Exemplo n.º 15
0
/* Add, del, test parser */
static ip_set_ip_t
adt_parser(unsigned cmd, const char *optarg, void *data)
{
	struct ip_set_req_nethash *mydata =
	    (struct ip_set_req_nethash *) data;
	char *saved = ipset_strdup(optarg);
	char *ptr, *tmp = saved;
	ip_set_ip_t cidr;

	ptr = strsep(&tmp, "/");
	
	if (tmp == NULL) {
		if (cmd == CMD_TEST)
			cidr = 32;
		else
			exit_error(PARAMETER_PROBLEM,
				   "Missing cidr from `%s'", optarg);
	} else
		if (string_to_number(tmp, 1, 31, &cidr))
			exit_error(PARAMETER_PROBLEM,
				   "Out of range cidr `%s' specified", optarg);
	
	mydata->cidr = cidr;
	parse_ip(ptr, &mydata->ip);
	if (!mydata->ip)
		exit_error(PARAMETER_PROBLEM,
			  "Zero valued IP address `%s' specified", ptr);
	free(saved);

	return mydata->ip;	
};
static void
parse_tos(const char *s, struct ipt_tos_info *info)
{
	unsigned int i;
	unsigned int tos;

	if (string_to_number(s, 0, 255, &tos) != -1) {
		
		/* start IP precedence and TOS remark by f00110348 */
		/*
		if (tos == IPTOS_LOWDELAY
		    || tos == IPTOS_THROUGHPUT
		    || tos == IPTOS_RELIABILITY
		    || tos == IPTOS_MINCOST
		    || tos == IPTOS_NORMALSVC) {*/
		 if ((tos >= 0) && (tos <= 255)) {
		/* end IP precedence and TOS remark by f00110348 */
		
		    	info->tos = (u_int8_t )tos;
		    	return;
		}
	} else {
		for (i = 0; i<sizeof(TOS_values)/sizeof(struct TOS_value); i++)
			if (strcasecmp(s,TOS_values[i].name) == 0) {
				info->tos = TOS_values[i].TOS;
				return;
			}
	}
	exit_error(PARAMETER_PROBLEM, "Bad TOS value `%s'", s);
}
Exemplo n.º 17
0
static struct in_addr *
parse_mask(char *mask)
{
	static struct in_addr maskaddr;
	struct in_addr *addrp;
	unsigned int bits;

	if (mask == NULL) {
		/* no mask at all defaults to 32 bits */
		maskaddr.s_addr = 0xFFFFFFFF;
		return &maskaddr;
	}
	if ((addrp = dotted_to_addr(mask)) != NULL)
		/* dotted_to_addr already returns a network byte order addr */
		return addrp;
	if (string_to_number(mask, 0, 32, &bits) == -1)
		xtables_error(PARAMETER_PROBLEM,
			      "invalid mask `%s' specified", mask);
	if (bits != 0) {
		maskaddr.s_addr = htonl(0xFFFFFFFF << (32 - bits));
		return &maskaddr;
	}

	maskaddr.s_addr = 0L;
	return &maskaddr;
}
Exemplo n.º 18
0
static struct in6_addr *parse_ip6_mask(char *mask)
{
	static struct in6_addr maskaddr;
	struct in6_addr *addrp;
	unsigned int bits;

	if (mask == NULL) {
		
		memset(&maskaddr, 0xff, sizeof maskaddr);
		return &maskaddr;
	}
	if ((addrp = numeric_to_addr(mask)) != NULL)
		return addrp;
	if (string_to_number(mask, 0, 128, &bits) == -1)
		ebt_print_error("Invalid IPv6 Mask '%s' specified", mask);
	if (bits != 0) {
		char *p = (char *)&maskaddr;
		memset(p, 0xff, bits / 8);
		memset(p + (bits / 8) + 1, 0, (128 - bits) / 8);
		p[bits / 8] = 0xff << (8 - (bits & 7));
		return &maskaddr;
	}

	memset(&maskaddr, 0, sizeof maskaddr);
	return &maskaddr;
}
Exemplo n.º 19
0
static u_int8_t
parse_level(const char *level)
{
	unsigned int lev = -1;
	unsigned int set = 0;

	if (string_to_number(level, 0, 7, &lev) == -1) {
		unsigned int i = 0;

		for (i = 0;
		     i < sizeof(ip6t_log_names) / sizeof(struct ip6t_log_names);
		     i++) {
			if (strncasecmp(level, ip6t_log_names[i].name,
					strlen(level)) == 0) {
				if (set++)
					exit_error(PARAMETER_PROBLEM,
						   "log-level `%s' ambiguous",
						   level);
				lev = ip6t_log_names[i].level;
			}
		}

		if (!set)
			exit_error(PARAMETER_PROBLEM,
				   "log-level `%s' unknown", level);
	}

	return (u_int8_t)lev;
}
Exemplo n.º 20
0
/*
 * Get IP address and port from the argument.
 * Return 0 if failed,
 *	  1 if addr read
 *        2 if addr and port read
 */
int
parse_addrport(char *buf, u_int16_t proto, u_int32_t * addr,
	       u_int16_t * port)
{
	char *pp;
	long prt;
	struct in_addr inaddr;

	pp = strchr(buf, ':');
	if (pp)
		*pp = '\0';

	if (inet_aton(buf, &inaddr) != 0)
		*addr = inaddr.s_addr;
	else if (host_to_addr(buf, &inaddr) != -1)
		*addr = inaddr.s_addr;
	else
		return 0;

	if (pp == NULL)
		return 1;

	if ((prt = string_to_number(pp + 1, 0, 65535)) != -1)
		*port = htons(prt);
	else if ((prt = service_to_port(pp + 1, proto)) != -1)
		*port = htons(prt);
	else
		return 0;

	return 2;
}
Exemplo n.º 21
0
/* Function which parses command options; returns true if it
   ate an option */
static int
parse(int c, char **argv, int invert, unsigned int *flags,
      const struct ipt_entry *entry,
      unsigned int *nfcache,
      struct ipt_entry_match **match)
{
    struct ipt_rand_info *randinfo = (struct ipt_rand_info *)(*match)->data;
    unsigned int num;

    switch (c) {
    case '1':
        /* check for common mistakes... */
        if (invert)
            exit_error(PARAMETER_PROBLEM,
                       "Can't specify ! --average");
        if (*flags & IPT_RAND_OPT_AVERAGE)
            exit_error(PARAMETER_PROBLEM,
                       "Can't specify --average twice");

        /* Remember, this function will interpret a leading 0 to be
           Octal, a leading 0x to be hexdecimal... */
        if (string_to_number(optarg, 1, 99, &num) == -1 || num < 1)
            exit_error(PARAMETER_PROBLEM,
                       "bad --average `%s', must be between 1 and 99", optarg);

        /* assign the values */
        randinfo->average = (int)(num * 2.55);
        *flags |= IPT_RAND_OPT_AVERAGE;
        break;
    default:
        return 0;
    }
    return 1;
}
Exemplo n.º 22
0
/* Function which parses command options; returns true if it
   ate an option */
static int
parse(int c, char **argv, int invert, unsigned int *flags,
      const struct ipt_entry *entry,
      unsigned int *nfcache,
      struct ipt_entry_match **match)
{
	struct ipt_rateinfo *r = (struct ipt_rateinfo *)(*match)->data;
	unsigned int num;

	switch(c) {
	case '%':
		if (check_inverse(argv[optind-1], &invert, &optind, 0)) break;
		if (!parse_rate(optarg, &r->avg))
			exit_error(PARAMETER_PROBLEM,
				   "bad rate `%s'", optarg);
		break;

	case '$':
		if (check_inverse(argv[optind-1], &invert, &optind, 0)) break;
		if (string_to_number(optarg, 0, 10000, &num) == -1)
			exit_error(PARAMETER_PROBLEM,
				   "bad --limit-burst `%s'", optarg);
		r->burst = num;
		break;

	default:
		return 0;
	}

	if (invert)
		exit_error(PARAMETER_PROBLEM,
			   "limit does not support invert");

	return 1;
}
Exemplo n.º 23
0
/** 
 *  @brief genevt proc write function
 *
 *  @param f	   file pointer
 *  @param buf     pointer to data buffer
 *  @param cnt     data number to write
 *  @param data    data to write
 *  @return 	   number of data
 */
static int
wlan_genevt_write(struct file *f, const char *buf, unsigned long cnt,
                  void *data)
{
    struct net_device *netdev = data;
    wlan_private *priv = netdev->priv;
    char databuf[10];
    int genevt;
    MODULE_GET;
    if (cnt > 10) {
        MODULE_PUT;
        return cnt;
    }
    if (copy_from_user(databuf, buf, cnt)) {
        MODULE_PUT;
        return 0;
    }
    genevt = string_to_number(databuf);
    switch (genevt) {
    case GEN_FATAL_ERROR_EVT:
        PRINTM(MSG, "proc: call wlan_fatal_error_handle\n");
        wlan_fatal_error_handle(priv);
        break;
    default:
        break;
    }
    MODULE_PUT;
    return cnt;
}
Exemplo n.º 24
0
static int parse(int c, char **argv, int argc,
      const struct ebt_u_entry *entry,
      unsigned int *flags,
      struct ebt_entry_match **match)
{
	struct ebt_limit_info *r = (struct ebt_limit_info *)(*match)->data;
	unsigned int num;

	switch(c) {
	case ARG_LIMIT:
		ebt_check_option2(flags, FLAG_LIMIT);
		if (ebt_check_inverse2(optarg))
			ebt_print_error2("Unexpected `!' after --limit");
		if (!parse_rate(optarg, &r->avg))
			ebt_print_error2("bad rate `%s'", optarg);
		break;

	case ARG_LIMIT_BURST:
		ebt_check_option2(flags, FLAG_LIMIT_BURST);
		if (ebt_check_inverse2(optarg))
			ebt_print_error2("Unexpected `!' after --limit-burst");
		if (string_to_number(optarg, 0, 10000, &num) == -1)
			ebt_print_error2("bad --limit-burst `%s'", optarg);
		r->burst = num;
		break;

	default:
		return 0;
	}

	return 1;
}
Exemplo n.º 25
0
/**
 *  @brief This function handle the generic file close
 *
 *  @param inode   A pointer to inode structure
 *  @param file    A pointer to file structure
 *  @return		N/A
 */
static void
proc_on_close(struct inode *inode, struct file *file)
{
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 10, 0)
	struct proc_private_data *priv = PDE_DATA(inode);
#else
	struct proc_private_data *priv = PDE(inode)->data;
#endif
	struct proc_data *pdata = file->private_data;
	char *line;
	int i;
	ENTER();
	if (!pdata->wrlen)
		return;
	line = pdata->wrbuf;
	while (line[0]) {
		for (i = 0; i < priv->num_items; i++) {
			if (!strncmp
			    (line, priv->pdata[i].name,
			     strlen(priv->pdata[i].name))) {
				line += strlen(priv->pdata[i].name) + 1;
				if (priv->pdata[i].size == 1)
					*((u8 *)priv->pdata[i].addr) =
						(u8)string_to_number(line);
				else if (priv->pdata[i].size == 2)
					*((u16 *) priv->pdata[i].addr) =
						(u16) string_to_number(line);
				else if (priv->pdata[i].size == 4)
					*((u32 *)priv->pdata[i].addr) =
						(u32)string_to_number(line);
			}
		}
		while (line[0] && line[0] != '\n')
			line++;
		if (line[0])
			line++;
	}
	if (priv->pbt->bt_dev.hscmd || priv->pbt->bt_dev.pscmd
	    || priv->pbt->bt_dev.sdio_pull_ctrl
	    || priv->pbt->bt_dev.test_mode || priv->pbt->bt_dev.hscfgcmd) {
		bt_prepare_command(priv->pbt);
		wake_up_interruptible(&priv->pbt->MainThread.waitQ);
	}
	LEAVE();
	return;
}
Exemplo n.º 26
0
static int parse(int c, char **argv, int invert, unsigned int *flags,
		const struct ip6t_entry *entry,
		struct ip6t_entry_target **target)
{
	struct ip6t_HL_info *info = (struct ip6t_HL_info *) (*target)->data;
	unsigned int value;

	if (*flags & IP6T_HL_USED) {
		exit_error(PARAMETER_PROBLEM, 
				"Can't specify HL option twice");
	}

	if (!optarg) 
		exit_error(PARAMETER_PROBLEM, 
				"HL: You must specify a value");

	if (check_inverse(optarg, &invert, NULL, 0))
		exit_error(PARAMETER_PROBLEM,
				"HL: unexpected `!'");
	
	if (string_to_number(optarg, 0, 255, &value) == -1)	
		exit_error(PARAMETER_PROBLEM,	
		           "HL: Expected value between 0 and 255");

	switch (c) {

		case '1':
			info->mode = IP6T_HL_SET;
			break;

		case '2':
			if (value == 0) {
				exit_error(PARAMETER_PROBLEM,
					"HL: decreasing by 0?");
			}

			info->mode = IP6T_HL_DEC;
			break;

		case '3':
			if (value == 0) {
				exit_error(PARAMETER_PROBLEM,
					"HL: increasing by 0?");
			}

			info->mode = IP6T_HL_INC;
			break;

		default:
			return 0;

	}
	
	info->hop_limit = value;
	*flags |= IP6T_HL_USED;

	return 1;
}
Exemplo n.º 27
0
bool expand_data(const std::string s, void **d, unsigned *siz)
{std::string buf;
 unsigned tam,t,f,g,len,sl,r=0,pos;
 bool err;
 char c[2];

	if (!bracketed_substr(s,buf,'(',')' ,&g)) return(false);
	string_to_number(buf,tam);
	if (siz!=0) *siz=tam;
	if (tam==0)
	{
		*d=0;
		return(true);
	}
	*d=new char[tam];
	pos=0;
	len=(unsigned)s.length();
	for (f=g; f<len; f++) if (s[f]=='\n') break;
	if (f>=len) return(false);
	f+=2;
	t=0;
	c[1]=0;
	err=false;
	while ((r<tam)&&(f<len))
	{
		while ((f<len)&&(s[f]=='\t')) f++;
		if (f<len)
		{
			g=f;
			while ((g<len)&&(s[g]!='\n')) g++;
			if (g<len)
			{
				buf=s.substr(f,g-f);
				sl=(unsigned)buf.length();
				for (unsigned h=0; h<sl; h+=2)
				{
					c[0]=read_hexbyte(buf[h],buf[h+1]);
					if (!err)
					{
						r++;
						((unsigned char *)(*d))[pos]=c[0];
						pos++;
					}
				}
				if (!err) f=g+1;
			}
			else
			{
				f=len;
				err=true;
			}
		}
		else err=true;
	}
	if (err) return(false);
	return(true);
}
Exemplo n.º 28
0
std::string expand_str(const std::string &s)
{std::string res,buf;
 unsigned tam,t,f,g,len,sl,r=0;
 bool err;
 char c[2];

	if (!bracketed_substr(s,buf,'(',')')) return(res);
	string_to_number(buf,tam);
	len=(unsigned)s.length();
	for (f=0; f<len; f++) if (s[f]=='\n') break;
	if (f>=len) return(res);
	f+=2;
	t=0;
	c[1]=0;
	err=false;
	while ((r<tam)&&(f<len))
	{
		while ((f<len)&&(s[f]=='\t')) f++;
		if (f<len)
		{
			g=f;
			while ((g<len)&&(s[g]!='\n')) g++;
			if (g<len)
			{
				buf=s.substr(f,g-f);
				sl=(unsigned)buf.length();
				for (unsigned h=0; h<sl; h+=2)
				{
					if (buf[h]!='*') c[0]=read_hexbyte(buf[h],buf[h+1]);
					else
					{
						if (h+4>=sl) err=true;
						else
						{
							c[0]=read_hexword(buf[h+1],buf[h+2],buf[h+3],buf[h+4]);
							h+=3;
						}
					}
					if (!err)
					{
						r++;
						res+=c;
					}
				}
				if (!err) f=g+1;
			}
			else
			{
				f=len;
				err=true;
			}
		}
		else err=true;
	}
	if (err) return("");
	return(res);
}
Exemplo n.º 29
0
static int parse_service(char *buf, ipvs_service_t *svc)
{
  char *portp = NULL;
  long portn;
  int result=SERVICE_NONE;
  struct in_addr inaddr;
  struct in6_addr inaddr6;

  if (buf == NULL || str_is_digit(buf))
    return SERVICE_NONE;
  if (buf[0] == '[') {
    buf++;
    portp = strchr(buf, ']');
    if (portp == NULL)
      return SERVICE_NONE;
    *portp = '\0';
    portp++;
    if (*portp == ':')
      *portp = '\0';
    else
      return SERVICE_NONE;
  }
  if (inet_pton(AF_INET6, buf, &inaddr6) > 0) {
    svc->addr.in6 = inaddr6;
    svc->af = AF_INET6;
    svc->netmask = 128;
  } else {
    portp = strrchr(buf, ':');
    if (portp != NULL)
      *portp = '\0';

    if (inet_aton(buf, &inaddr) != 0) {
      svc->addr.ip = inaddr.s_addr;
      svc->af = AF_INET;
    } else if (host_to_addr(buf, &inaddr) != -1) {
      svc->addr.ip = inaddr.s_addr;
      svc->af = AF_INET;
    } else
      return SERVICE_NONE;
  }

  result |= SERVICE_ADDR;

  if (portp != NULL) {
    result |= SERVICE_PORT;

    if ((portn = string_to_number(portp+1, 0, 65535)) != -1)
      svc->port = htons(portn);
    else if ((portn = service_to_port(portp+1, svc->protocol)) != -1)
      svc->port = htons(portn);
    else
      return SERVICE_NONE;
  }

  return result;
}
Exemplo n.º 30
0
static void
parse_tcp_option(const char *option, u_int8_t *result)
{
	unsigned int ret;

	if (string_to_number(option, 1, 255, &ret) == -1)
		exit_error(PARAMETER_PROBLEM, "Bad TCP option `%s'", option);

	*result = (u_int8_t)ret;
}