static bool
hhmm_to_seconds(const std::string & HHMM,
unsigned long & seconds)
{
unsigned long tmp;
std::string hours;
std::string minutes;
if (!split(HHMM, hours, minutes, ':'))
return false;
if (!str_to_ulong(hours.c_str(), seconds))
return false;
if (23 < seconds)
return false;
seconds = seconds * SECONDS_IN_HOUR;
if (!str_to_ulong(minutes.c_str(), tmp))
return false;
if (59 < tmp)
return false;
tmp = tmp * 60;
seconds += tmp;
return true;
}
int str_to_uint(const char *string, unsigned int *number, const int base)
{
unsigned long num;
*number = 0;
if (!str_to_ulong(string, &num, base))
return 0;
if (num > UINT_MAX) {
errno = ERANGE;
return 0;
}
*number = num;
return 1;
}
static int
mail_export_parse_filter(const char *const *args, pool_t pool,
struct mail_export_filter *filter_r,
const char **error_r)
{
unsigned long l;
/* filters:
user=<wildcard> | domain=<wildcard>
ip=<ip>[/<mask>]
since=<timestamp>
connected
*/
memset(filter_r, 0, sizeof(*filter_r));
for (; *args != NULL; args++) {
if (strncmp(*args, "user="******"domain=", 7) == 0)
filter_r->domain = p_strdup(pool, *args + 7);
else if (strncmp(*args, "ip=", 3) == 0) {
if (net_parse_range(*args + 3, &filter_r->ip,
&filter_r->ip_bits) < 0) {
*error_r = "Invalid ip filter";
return -1;
}
} else if (strncmp(*args, "since=", 6) == 0) {
if (str_to_ulong(*args + 6, &l) < 0) {
*error_r = "Invalid since filter";
return -1;
}
filter_r->since = (time_t)l;
} else if (strcmp(*args, "connected") == 0) {
filter_r->connected = TRUE;
}
}
return 0;
}
static bool auth_handle_response(struct digest_auth_request *request,
char *key, char *value, const char **error)
{
unsigned int i;
(void)str_lcase(key);
if (strcmp(key, "realm") == 0) {
if (request->auth_request.realm == NULL && *value != '\0')
request->auth_request.realm =
p_strdup(request->pool, value);
return TRUE;
}
if (strcmp(key, "username") == 0) {
if (request->username != NULL) {
*error = "username must not exist more than once";
return FALSE;
}
if (*value == '\0') {
*error = "empty username";
return FALSE;
}
request->username = p_strdup(request->pool, value);
return TRUE;
}
if (strcmp(key, "nonce") == 0) {
/* nonce must be same */
if (strcmp(value, request->nonce) != 0) {
*error = "Invalid nonce";
return FALSE;
}
request->nonce_found = TRUE;
return TRUE;
}
if (strcmp(key, "cnonce") == 0) {
if (request->cnonce != NULL) {
*error = "cnonce must not exist more than once";
return FALSE;
}
if (*value == '\0') {
*error = "cnonce can't contain empty value";
return FALSE;
}
request->cnonce = p_strdup(request->pool, value);
return TRUE;
}
if (strcmp(key, "nc") == 0) {
unsigned int nc;
if (request->nonce_count != NULL) {
*error = "nonce-count must not exist more than once";
return FALSE;
}
if (str_to_uint(value, &nc) < 0) {
*error = "nonce-count value invalid";
return FALSE;
}
if (nc != 1) {
*error = "re-auth not supported currently";
return FALSE;
}
request->nonce_count = p_strdup(request->pool, value);
return TRUE;
}
if (strcmp(key, "qop") == 0) {
for (i = 0; i < QOP_COUNT; i++) {
if (strcasecmp(qop_names[i], value) == 0)
break;
}
if (i == QOP_COUNT) {
*error = t_strdup_printf("Unknown QoP value: %s",
str_sanitize(value, 32));
return FALSE;
}
request->qop &= (1 << i);
if (request->qop == 0) {
*error = "Nonallowed QoP requested";
return FALSE;
}
request->qop_value = p_strdup(request->pool, value);
return TRUE;
}
if (strcmp(key, "digest-uri") == 0) {
/* type / host / serv-name */
const char *const *uri = t_strsplit(value, "/");
if (uri[0] == NULL || uri[1] == NULL) {
*error = "Invalid digest-uri";
return FALSE;
}
/* FIXME: RFC recommends that we verify the host/serv-type.
But isn't the realm enough already? That'd be just extra
configuration.. Maybe optionally list valid hosts in
config file? */
request->digest_uri = p_strdup(request->pool, value);
return TRUE;
}
if (strcmp(key, "maxbuf") == 0) {
if (request->maxbuf != 0) {
*error = "maxbuf must not exist more than once";
return FALSE;
}
if (str_to_ulong(value, &request->maxbuf) < 0 ||
request->maxbuf == 0) {
*error = "Invalid maxbuf value";
return FALSE;
}
return TRUE;
}
if (strcmp(key, "charset") == 0) {
if (strcasecmp(value, "utf-8") != 0) {
*error = "Only utf-8 charset is allowed";
return FALSE;
}
return TRUE;
}
if (strcmp(key, "response") == 0) {
if (strlen(value) != 32) {
*error = "Invalid response value";
return FALSE;
}
memcpy(request->response, value, 32);
return TRUE;
}
if (strcmp(key, "cipher") == 0) {
/* not supported, ignore */
return TRUE;
}
if (strcmp(key, "authzid") == 0) {
if (request->authzid != NULL) {
*error = "authzid must not exist more than once";
return FALSE;
}
if (*value == '\0') {
*error = "empty authzid";
return FALSE;
}
request->authzid = p_strdup(request->pool, value);
return TRUE;
}
/* unknown key, ignore */
return TRUE;
}
bool
ConfigItemFIXSession::get(struct FIX_Session_Config & session_config)
{
std::vector<std::string> items;
std::map<std::string, std::string> session_props;
ConfigItemNetwork ci_network;
std::vector<endpoint_t> enpoints;
if (!config_vector_item_.get(items)) {
M_ERROR("could not get vector item");
return false;
}
std::string token;
std::string value;
for (size_t n = 0; n < items.size(); ++n) {
if (!split(items[n], token, value, ':'))
return false;
if (token.size() && value.size())
session_props[token] = value;;
}
if (!check_session_props(session_props))
return false;
if ("YES" == session_props[DUPLEX_KEY]) {
session_config.is_duplex = true;
} else {
session_config.is_duplex = false;
}
session_config.must_initiate_logon = ("YES" == session_props[MUST_INITIATE_LOGON_KEY]);
session_config.reset_seq_numbers_at_logon = ("YES" == session_props[RESET_SEQ_NUMBERS_AT_LOGON_KEY]);
std::vector<std::string> days;
if (!make_vector(days, session_props[SESSION_DAYS_KEY].c_str(), ","))
goto err;
for (size_t n = 0; n < 7; ++n) {
session_config.session_days_[n] = false;
}
for (size_t n = 0; n < days.size(); ++n) {
if (SUNDAY == days[n]) {
session_config.session_days_[0] = true;
continue;
}
if (MONDAY == days[n]) {
session_config.session_days_[1] = true;
continue;
}
if (TUESDAY == days[n]) {
session_config.session_days_[2] = true;
continue;
}
if (WEDNESDAY == days[n]) {
session_config.session_days_[3] = true;
continue;
}
if (THURSDAY == days[n]) {
session_config.session_days_[4] = true;
continue;
}
if (FRIDAY == days[n]) {
session_config.session_days_[5] = true;
continue;
}
if (SATURDAY == days[n]) {
session_config.session_days_[6] = true;
continue;
}
goto err;
}
do {
if (FIX_4_0_VAL == session_props[FIX_APPLICATION_VER_KEY]) {
session_config.fixA_ver = FIX_4_0;
break;
}
if (FIX_4_1_VAL == session_props[FIX_APPLICATION_VER_KEY]) {
session_config.fixA_ver = FIX_4_1;
break;
}
if (FIX_4_2_VAL == session_props[FIX_APPLICATION_VER_KEY]) {
session_config.fixA_ver = FIX_4_2;
break;
}
if (FIX_4_3_VAL == session_props[FIX_APPLICATION_VER_KEY]) {
session_config.fixA_ver = FIX_4_3;
break;
}
if (FIX_4_4_VAL == session_props[FIX_APPLICATION_VER_KEY]) {
session_config.fixA_ver = FIX_4_4;
break;
}
if (FIX_5_0_VAL == session_props[FIX_APPLICATION_VER_KEY]) {
session_config.fixA_ver = FIX_5_0;
break;
}
if (FIX_5_0_SP1_VAL == session_props[FIX_APPLICATION_VER_KEY]) {
session_config.fixA_ver = FIX_5_0_SP1;
break;
}
if (FIX_5_0_SP2_VAL == session_props[FIX_APPLICATION_VER_KEY]) {
session_config.fixA_ver = FIX_5_0_SP2;
break;
}
goto err;
} while (false);
do {
if (NO_FIXT_VAL == session_props[FIX_SESSION_VER_KEY]) {
session_config.fixT_ver = NO_FIXT;
break;
}
if (FIXT_1_1_VAL == session_props[FIX_SESSION_VER_KEY]) {
session_config.fixT_ver = FIXT_1_1;
break;
}
goto err;
} while (false);
if (!str_to_ulong(session_props[HEARTBEAT_INTERVAL_KEY].c_str(), session_config.heartbeat_interval))
goto err;
if (!str_to_ulong(session_props[TEST_REQUEST_DELAY_KEY].c_str(), session_config.test_request_delay))
goto err;
if (!str_to_ulong(session_props[SESSION_WARM_UP_TIME_KEY].c_str(), session_config.session_warm_up_time))
goto err;
if (!hhmm_to_seconds(session_props[SESSION_START_KEY], session_config.session_start))
goto err;
if (!hhmm_to_seconds(session_props[SESSION_END_KEY], session_config.session_end))
goto err;
if (!session_props[TIMEZONE_KEY].size())
goto err;
session_config.timezone = strdup(session_props[TIMEZONE_KEY].c_str());
if (!session_config.timezone)
goto err;
switch (session_config.is_duplex) {
case true:
ci_network.fill(data_source_, session_props[ENDPOINT_IN_OUT_KEY].c_str());
ci_network.get(enpoints);
if (1 != enpoints.size())
goto err;
session_config.in_going.kind = enpoints[0].kind;
session_config.in_going.interface = enpoints[0].interface;
session_config.in_going.port = enpoints[0].port;
session_config.in_going.pf_family = enpoints[0].pf_family;
session_config.out_going.kind = enpoints[0].kind;
session_config.out_going.interface = enpoints[0].interface;
session_config.out_going.port = enpoints[0].port;
session_config.out_going.pf_family = enpoints[0].pf_family;
break;
case false:
ci_network.fill(data_source_, session_props[ENDPOINT_IN_GOING_KEY].c_str());
ci_network.get(enpoints);
if (1 != enpoints.size())
goto err;
session_config.in_going.kind = enpoints[0].kind;
session_config.in_going.interface = enpoints[0].interface;
session_config.in_going.port = enpoints[0].port;
session_config.in_going.pf_family = enpoints[0].pf_family;
ci_network.fill(data_source_, session_props[ENDPOINT_OUT_GOING_KEY].c_str());
ci_network.get(enpoints);
if (1 != enpoints.size())
goto err;
session_config.out_going.kind = enpoints[0].kind;
session_config.out_going.interface = enpoints[0].interface;
session_config.out_going.port = enpoints[0].port;
session_config.out_going.pf_family = enpoints[0].pf_family;
break;
default:
goto err;
}
return true;
err:
return false;
}
int str_is_ulong(const char *string, const int base)
{
unsigned long number;
return str_to_ulong(string, &number, base);
}
static
int
advert_parse(int c, char **argv, int invert, unsigned int *flags,
const void *entry, struct xt_entry_target **target)
{
struct xt_advert_tginfo *info = (void*)(*target)->data;
if (info->count == MAX_NETS)
xtables_error(PARAMETER_PROBLEM, "ADVERT: too many nets");
struct ipnet *net = info->ipnets + info->count;
switch (c) {
case 'n':
if (-1 == parse_ipnet(optarg, net))
xtables_error(PARAMETER_PROBLEM, "ADVERT: bad network given");
if (net->masklen < MIN_MASKLEN)
xtables_error(PARAMETER_PROBLEM, "ADVERT: too big network");
// printf("%s parsed %s/%d\n", optarg, ip_to_sa(net->ip), net->masklen);
info->count++;
*flags |= NETS_PRESENT;
return true;
case 'u':
if (*flags & URL_PRESENT)
xtables_error(PARAMETER_PROBLEM, "ADVERT: url already set");
__u32 len = strlen(optarg);
if (len > MAX_URLLEN)
xtables_error(PARAMETER_PROBLEM, "ADVERT: url too long");
// info->url_len = len;
memcpy(info->url, optarg, len+1);
*flags |= URL_PRESENT;
return true;
case 'i':
if (*flags & INTERVAL_PRESENT)
xtables_error(PARAMETER_PROBLEM, "ADVERT: interval already set");
{
char *endptr;
unsigned long n;
if (-1 == str_to_ulong(optarg, &endptr, &n, INTERVAL_MAX) || *endptr)
xtables_error(PARAMETER_PROBLEM, "ADVERT: incorrect interval");
info->interval = n;
}
*flags |= INTERVAL_PRESENT;
return true;
default:
return false;
}
return false;
}
