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); }
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; }
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; }
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; }
//============================================================================== 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; }
// 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); }
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; }
//============================================================================== 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; }
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"); } }
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); } } } }
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; }
/* 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; }
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); } }
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); }
/* 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); }
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; }
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; }
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; }
/* * 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; }
/* 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; }
/* 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; }
/** * @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; }
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; }
/** * @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; }
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; }
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); }
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); }
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; }
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; }