// 活动
apr_status_t event_duplicate_parser(
apr_size_t nargs,
char ** argv,
apr_hash_t * res_subhash,
apr_pool_t * res_pool)
{
event_duplicate_t * ed = (event_duplicate_t *)
apr_palloc(res_pool, sizeof(event_duplicate_t));
ed->id = (apr_int32_t)apr_atoi64(argv[0]);
ed->cycle_mode = (apr_int32_t)apr_atoi64(argv[2]);
ed->begin_time = 0;
ed->duration = (apr_int32_t)apr_atoi64(argv[4]);
ed->battle_node[0] = 0;
ed->battle_node[1] = 0;
ed->battle_node[2] = 0;
apr_int32_t key = ed->id;
if (apr_hash_get(res_subhash, &key, sizeof(key)) == NULL) {
apr_hash_set(res_subhash, &key, sizeof(key), ed);
} else {
fprintf(stderr,
"[RES] FAULT: duplicate key = %d\n",
key);
}
return APR_SUCCESS;
}
// 符石抽奖
apr_status_t lottery_stone_parser(
apr_size_t nargs,
char ** argv,
apr_hash_t * res_subhash,
apr_pool_t * res_pool)
{
lottery_stone_t * ls = (lottery_stone_t *)
apr_palloc(res_pool, sizeof(lottery_stone_t));
ls->group_id = (apr_int32_t)apr_atoi64(argv[0]);
ls->ptt_id = (card_ptt_id_t)apr_atoi64(argv[1]);
ls->ptt_prob = (apr_int32_t)apr_atoi64(argv[2]);
apr_int32_t key = ls->group_id;
apr_hash_t * group_hash = (apr_hash_t *)
apr_hash_get(res_subhash, &key, sizeof(key));
if (group_hash == NULL) {
group_hash = apr_hash_make(res_pool);
apr_hash_set(res_subhash,
&key,
sizeof(key),
group_hash);
}
apr_hash_set(group_hash,
&ls->ptt_id,
sizeof(ls->ptt_id),
ls);
return APR_SUCCESS;
}
// 卡牌
apr_status_t card_ptt_parser(
apr_size_t nargs,
char ** argv,
apr_hash_t * res_subhash,
apr_pool_t * res_pool)
{
card_ptt_t * ptt = (card_ptt_t *)
apr_palloc(res_pool, sizeof(card_ptt_t));
ptt->id = (card_ptt_id_t)apr_atoi64(argv[0]);
ptt->class_info = (apr_int32_t)apr_atoi64(argv[7]);
ptt->leadership_cost = (apr_int32_t)apr_atoi64(argv[12]);
ptt->levelup_exp_type = (apr_int32_t)apr_atoi64(argv[13]);
ptt->level_max = (apr_int32_t)apr_atoi64(argv[14]);
ptt->hp_base = (apr_int32_t)apr_atoi64(argv[15]);
ptt->att_base = (apr_int32_t)apr_atoi64(argv[18]);
ptt->compose_exp_base = (apr_int32_t)apr_atoi64(argv[24]);
ptt->sell_gold_base = (apr_int16_t)apr_atoi64(argv[25]);
card_ptt_id_t key = ptt->id;
if (apr_hash_get(res_subhash, &key, sizeof(key)) == NULL) {
apr_hash_set(res_subhash, &key, sizeof(key), ptt);
} else {
fprintf(stderr,
"[RES] FAULT: duplicate key = %d\n",
key);
}
return APR_SUCCESS;
}
static void aos_curl_transport_headers_done(aos_curl_http_transport_t *t)
{
long http_code;
CURLcode code;
const char *value;
if (t->controller->error_code != AOSE_OK) {
aos_debug_log("has error %d.", t->controller->error_code);
return;
}
if (t->resp->status > 0) {
aos_trace_log("http response status %d.", t->resp->status);
return;
}
t->resp->status = 0;
if ((code = curl_easy_getinfo(t->curl, CURLINFO_RESPONSE_CODE, &http_code)) != CURLE_OK) {
t->controller->reason = apr_pstrdup(t->pool, curl_easy_strerror(code));
t->controller->error_code = AOSE_INTERNAL_ERROR;
return;
} else {
t->resp->status = http_code;
}
value = apr_table_get(t->resp->headers, "Content-Length");
if (value != NULL) {
t->resp->content_length = apr_atoi64(value);
}
}
// returns the payload version, 0 if error msg, -1 if header not found
int extract_payload_from_header(apr_pool_t *pool, apr_table_t *headers, const char **payload3, const char **payload1) {
*payload3 = NULL;
*payload1 = NULL;
const char *header_value = apr_table_get(headers, MOBILE_SDK_HEADER);
if (header_value) {
char *rest;
char *header_cpy = apr_pstrdup(pool, header_value);
const char *prefix = apr_strtok(header_cpy, ":", &rest);
if (prefix == NULL) {
// Setting payload to "" so it will fail on decryption
*payload3 = "";
return 0;
}
const char *postfix = apr_strtok(NULL, "", &rest);
// if postfix is empty, use prefix as payload number, in this case version will be 0
if (postfix == NULL) {
*payload3 = prefix;
return 0;
}
int version = apr_atoi64(prefix);
switch (version) {
case 1:
*payload1 = postfix;
break;
case 3:
*payload3 = postfix;
break;
default:
return -1;
}
return version;
}
return -1;
}
/**
* Parse an Alt-Svc specifier as described in "HTTP Alternative Services"
* (https://tools.ietf.org/html/draft-ietf-httpbis-alt-svc-04)
* with the following changes:
* - do not percent encode token values
* - do not use quotation marks
*/
h2_alt_svc *h2_alt_svc_parse(const char *s, apr_pool_t *pool) {
const char *sep = ap_strchr_c(s, '=');
if (sep) {
const char *alpn = apr_pstrndup(pool, s, sep - s);
const char *host = NULL;
int port = 0;
s = sep + 1;
sep = ap_strchr_c(s, ':'); /* mandatory : */
if (sep) {
if (sep != s) { /* optional host */
host = apr_pstrndup(pool, s, sep - s);
}
s = sep + 1;
if (*s) { /* must be a port number */
port = (int)apr_atoi64(s);
if (port > 0 && port < (0x1 << 16)) {
h2_alt_svc *as = apr_pcalloc(pool, sizeof(*as));
as->alpn = alpn;
as->host = host;
as->port = port;
return as;
}
}
}
}
return NULL;
}
static const char *h2_conf_set_max_worker_idle_secs(cmd_parms *parms,
void *arg, const char *value)
{
h2_config *cfg = h2_config_sget(parms->server);
cfg->max_worker_idle_secs = (int)apr_atoi64(value);
(void)arg;
return NULL;
}
static const char *h2_conf_set_max_hl_size(cmd_parms *parms,
void *arg, const char *value)
{
h2_config *cfg = h2_config_sget(parms->server);
cfg->h2_max_hl_size = (int)apr_atoi64(value);
(void)arg;
return NULL;
}
// 玩家升级
apr_status_t actor_levelup_parser(
apr_size_t nargs,
char ** argv,
apr_hash_t * res_subhash,
apr_pool_t * res_pool)
{
actor_levelup_t * lu = (actor_levelup_t *)
apr_palloc(res_pool, sizeof(actor_levelup_t));
lu->level = (level_t)apr_atoi64(argv[0]);
lu->to_next_level = (apr_int32_t)apr_atoi64(argv[1]);
lu->stamina_max = (apr_int32_t)apr_atoi64(argv[2]);
lu->cards_max = (apr_int32_t)apr_atoi64(argv[3]);
lu->leadership_max = (apr_int32_t)apr_atoi64(argv[4]);
lu->friends_max = (apr_int32_t)apr_atoi64(argv[5]);
lu->stamina_reward = (apr_int32_t)apr_atoi64(argv[6]);
level_t key = lu->level;
if (apr_hash_get(res_subhash, &key, sizeof(key)) == NULL) {
apr_hash_set(res_subhash, &key, sizeof(key), lu);
} else {
fprintf(stderr,
"[RES] FAULT: duplicate key = %d\n",
key);
}
return APR_SUCCESS;
}
const char *
but_config_session_inactivity_timeout(cmd_parms *cmd, void *dummy, const char *arg)
{
mod_but_server_t *conf = ap_get_module_config(cmd->server->module_config, &but_module);
if (arg) {
conf->session_inactivity_timeout = apr_atoi64(arg);
}
return OK;
}
static int find_cookie(request_rec *r,char **user,uint8_t *secret,int secretLen) {
char *cookie=0l;
char *cookie_expire=0l;
char *cookie_valid=0l;
ap_regmatch_t regmatch[AP_MAX_REG_MATCH];
authn_google_config_rec *conf = ap_get_module_config(r->per_dir_config, &authn_google_module);
cookie = (char *) apr_table_get(r->headers_in, "Cookie");
if (cookie) {
if (conf->debugLevel)
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
"Found cookie \"%s\"",cookie);
if (!ap_regexec(cookie_regexp, cookie, AP_MAX_REG_MATCH, regmatch, 0)) {
if (user) *user = ap_pregsub(r->pool, "$2", cookie,AP_MAX_REG_MATCH,regmatch);
cookie_expire = ap_pregsub(r->pool, "$3", cookie,AP_MAX_REG_MATCH,regmatch);
cookie_valid = ap_pregsub(r->pool, "$4", cookie,AP_MAX_REG_MATCH,regmatch);
if (conf->debugLevel)
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
"Found cookie Expires \"%s\" Valid \"%s\"",cookie_expire,cookie_valid);
if (cookie_expire && cookie_valid && *user) {
long unsigned int exp = apr_atoi64(cookie_expire);
long unsigned int now = apr_time_now()/1000000;
if (exp < now) {
if (conf->debugLevel)
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
"Expired. Now=%lu Expire=%lu\n",now,exp);
return 0; /* Expired */
}
if (!secret) {
secret = getUserSecret(r,*user,&secretLen,0L);
}
char *h = hash_cookie(r->pool,secret,secretLen,exp);
if (conf->debugLevel)
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
"Match cookie \"%s\" vs \"%s\"",h,cookie_valid);
if (apr_strnatcmp(h,cookie_valid)==0)
return 1; /* Valid Cookie */
else {
if (conf->debugLevel)
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
"MISMATCHED cookie \"%s\" vs \"%s\"",h,cookie_valid);
return 0; /* Mismatched */
}
}
}
}
return 0; /* Not found */
}
static const char *h2_conf_set_window_size(cmd_parms *parms,
void *arg, const char *value)
{
h2_config *cfg = (h2_config *)h2_config_sget(parms->server);
cfg->h2_window_size = (int)apr_atoi64(value);
(void)arg;
if (cfg->h2_window_size < 1024) {
return "value must be >= 1024";
}
return NULL;
}
/** Parse MRCP request-id */
MRCP_DECLARE(mrcp_request_id) mrcp_request_id_parse(const apt_str_t *field)
{
if(field->buf) {
#ifdef TOO_LONG_MRCP_REQUEST_ID
return apr_atoi64(field->buf);
#else
return atol(field->buf);
#endif
}
return 0;
}
static const char *h2_conf_set_max_worker_idle_secs(cmd_parms *parms,
void *arg, const char *value)
{
h2_config *cfg = (h2_config *)h2_config_sget(parms->server);
cfg->max_worker_idle_secs = (int)apr_atoi64(value);
(void)arg;
if (cfg->max_worker_idle_secs < 1) {
return "value must be > 0";
}
return NULL;
}
static const char *h2_conf_set_min_workers(cmd_parms *parms,
void *arg, const char *value)
{
h2_config *cfg = h2_config_sget(parms->server);
cfg->min_workers = (int)apr_atoi64(value);
(void)arg;
if (cfg->min_workers < 1) {
return "value must be > 1";
}
return NULL;
}
static unsigned int parse_number(const char *string, const char *name, apr_int64_t min, apr_int64_t max,
apr_int64_t default_value, server_rec *s) {
if (string == NULL) {
return default_value;
}
apr_int64_t value = apr_atoi64(string);
if (errno != 0 || value > max || value < min) {
ap_log_error(APLOG_MARK, APLOG_EMERG, errno, s, "Could not parse %s: '%s'", name, string);
exit(1);
}
return value;
}
// 队长技能
apr_status_t captskill_parser(
apr_size_t nargs,
char ** argv,
apr_hash_t * res_subhash,
apr_pool_t * res_pool)
{
captskill_t * s =
(captskill_t *)apr_palloc(res_pool, sizeof(captskill_t));
s->id = (captskill_id_t)apr_atoi64(argv[0]);
s->plus0 = (apr_int32_t)apr_atoi64(argv[5]);
s->plus1 = (apr_int32_t)apr_atoi64(argv[6]);
s->plus2 = (apr_int32_t)apr_atoi64(argv[7]);
s->plus3 = (apr_int32_t)apr_atoi64(argv[8]);
s->plus4 = (apr_int32_t)apr_atoi64(argv[9]);
captskill_id_t key = s->id;
if (apr_hash_get(res_subhash, &key, sizeof(key)) == NULL) {
apr_hash_set(res_subhash, &key, sizeof(key), s);
} else {
fprintf(stderr,
"[RES] FAULT: duplicate key = %d\n",
key);
}
return APR_SUCCESS;
}
// 任务
apr_status_t quest_ptt_parser(
apr_size_t nargs,
char ** argv,
apr_hash_t * res_subhash,
apr_pool_t * res_pool)
{
quest_ptt_t * ptt = (quest_ptt_t *)
apr_palloc(res_pool, sizeof(quest_ptt_t));
ptt->id = (quest_ptt_id_t)apr_atoi64(argv[0]);
ptt->pre_quest_id = (apr_int32_t)apr_atoi64(argv[5]);
ptt->reward_type = (apr_int32_t)apr_atoi64(argv[6]);
ptt->reward_param = (apr_int32_t)apr_atoi64(argv[7]);
ptt->cond1_type = (apr_int32_t)apr_atoi64(argv[8]);
ptt->cond1_param = (apr_int32_t)apr_atoi64(argv[9]);
quest_ptt_id_t key = ptt->id;
if (apr_hash_get(res_subhash, &key, sizeof(key)) == NULL) {
apr_hash_set(res_subhash, &key, sizeof(key), ptt);
} else {
fprintf(stderr,
"[RES] FAULT: duplicate key = %d\n",
key);
}
return APR_SUCCESS;
}
static const char *h2_conf_set_stream_max_mem_size(cmd_parms *parms,
void *arg, const char *value)
{
h2_config *cfg = h2_config_sget(parms->server);
cfg->stream_max_mem_size = (int)apr_atoi64(value);
(void)arg;
if (cfg->stream_max_mem_size < 1024) {
return "value must be > 1k";
}
return NULL;
}
// 卡牌合成
apr_status_t card_compose_parser(
apr_size_t nargs,
char ** argv,
apr_hash_t * res_subhash,
apr_pool_t * res_pool)
{
card_compose_t * clu = (card_compose_t *)
apr_palloc(res_pool, sizeof(card_compose_t));
clu->level = (level_t)apr_atoi64(argv[0]);
clu->compose_exp[0] = (apr_int32_t)apr_atoi64(argv[1]);
clu->compose_exp[1] = (apr_int32_t)apr_atoi64(argv[2]);
clu->compose_exp[2] = (apr_int32_t)apr_atoi64(argv[3]);
clu->compose_exp[3] = (apr_int32_t)apr_atoi64(argv[4]);
level_t key = clu->level;
if (apr_hash_get(res_subhash, &key, sizeof(key)) == NULL) {
apr_hash_set(res_subhash, &key, sizeof(key), clu);
} else {
fprintf(stderr,
"[RES] FAULT: duplicate key = %d\n",
key);
}
return APR_SUCCESS;
}
// copied from mod_session.c
static apr_status_t oidc_session_identity_decode(request_rec * r,
session_rec * z) {
char *last = NULL;
char *encoded, *pair;
const char *sep = "&";
//oidc_debug(r, "decoding %s", z->encoded);
/* sanity check - anything to decode? */
if (!z->encoded) {
return APR_SUCCESS;
}
/* decode what we have */
encoded = apr_pstrdup(r->pool, z->encoded);
pair = apr_strtok(encoded, sep, &last);
while (pair && pair[0]) {
char *plast = NULL;
const char *psep = "=";
char *key = apr_strtok(pair, psep, &plast);
char *val = apr_strtok(NULL, psep, &plast);
//oidc_debug(r, "decoding %s=%s", key, val);
if (key && *key) {
if (!val || !*val) {
apr_table_unset(z->entries, key);
} else if (!ap_unescape_urlencoded(key)
&& !ap_unescape_urlencoded(val)) {
if (!strcmp(OIDC_SESSION_EXPIRY_KEY, key)) {
z->expiry = (apr_time_t) apr_atoi64(val);
} else {
apr_table_set(z->entries, key, val);
}
}
}
pair = apr_strtok(NULL, sep, &last);
}
z->encoded = NULL;
return APR_SUCCESS;
}
// 卡牌进化
apr_status_t card_evolution_parser(
apr_size_t nargs,
char ** argv,
apr_hash_t * res_subhash,
apr_pool_t * res_pool)
{
card_evolution_t * ce = (card_evolution_t *)
apr_palloc(res_pool, sizeof(card_evolution_t));
ce->id = (card_id_t)apr_atoi64(argv[0]);
ce->equip_set_required = (int)apr_atoi64(argv[1]);
ce->id_evo = (card_id_t)apr_atoi64(argv[2]);
ce->level_required = (level_t)apr_atoi64(argv[3]);
ce->type_required = (int)apr_atoi64(argv[4]);
ce->card1_required[0] = CARD_INVALID_ID;
ce->card1_required[1] = CARD_INVALID_ID;
ce->card2_required[0] = CARD_INVALID_ID;
ce->card2_required[1] = CARD_INVALID_ID;
ce->card3_required[0] = CARD_INVALID_ID;
ce->card3_required[1] = CARD_INVALID_ID;
ce->card4_required[0] = CARD_INVALID_ID;
ce->card4_required[1] = CARD_INVALID_ID;
ce->card5_required[0] = CARD_INVALID_ID;
ce->card5_required[1] = CARD_INVALID_ID;
ce->level_evo = (level_t)apr_atoi64(argv[10]);
ce->initsk_level_evo = (initskill_level_t)apr_atoi64(argv[11]);
ce->gold_required = (int)apr_atoi64(argv[13]);
card_id_t key = ce->id;
if (apr_hash_get(res_subhash, &key, sizeof(key)) == NULL) {
apr_hash_set(res_subhash, &key, sizeof(key), ce);
} else {
fprintf(stderr,
"[RES] FAULT: duplicate key = %d\n",
key);
}
return APR_SUCCESS;
}
/** Read the master job pid from file on disc. */
static int
trell_get_master_pid( trell_sconf_t* svr_conf, request_rec* r, pid_t* pid )
{
apr_status_t rv;
apr_file_t* pidfile = NULL;
rv = apr_file_open( &pidfile, master_job_pidfile_path,
APR_READ, APR_OS_DEFAULT, r->pool );
if( rv != APR_SUCCESS ) {
ap_log_rerror( APLOG_MARK, APLOG_NOTICE, rv, r, "mod_trell: Failed to open master job pid file for reading." );
return rv;
}
char* line = (char*)apr_palloc( r->pool, sizeof(unsigned char)*256 );
rv = apr_file_gets( line, 256, pidfile );
if( rv != APR_SUCCESS ) {
ap_log_rerror( APLOG_MARK, APLOG_NOTICE, rv, r, "mod_trell: %s@%d", __FILE__, __LINE__ );
return rv;
}
*pid = apr_atoi64( line );
return APR_SUCCESS;
}
/* return -1 means error */
static int parse_url (request_rec *r, const char *remote_url,
char **hostname, apr_int64_t *p_port_num,
char **filepath)
{
apr_pool_t *rp = r->pool;
char *p_port_str;
char *p_tmp;
*hostname = apr_pstrdup (rp, remote_url);
if (!strncasecmp (*hostname, "http://", 7)) {
*hostname += 7;
}
p_tmp = ap_strchr (*hostname, '/');
if (p_tmp) {
*filepath = apr_pstrdup (rp, p_tmp);
*p_tmp = '\0';
}
else {
*filepath = apr_pstrdup (rp, "/");
}
*p_port_num = DEF_PORT_NUM;
if (p_port_str = ap_strchr (*hostname, ':')) {
*p_port_str = '\0';
p_port_str++;
*p_port_num = apr_atoi64 (p_port_str);
}
if (errno == ERANGE) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "port number overflow");
return -1;
}
return 0;
}
// 主动技能
apr_status_t initskill_parser(
apr_size_t nargs,
char ** argv,
apr_hash_t * res_subhash,
apr_pool_t * res_pool)
{
initskill_ptt_t * ptt = (initskill_ptt_t *)
apr_palloc(res_pool, sizeof(initskill_ptt_t));
ptt->id = (initskill_id_t)apr_atoi64(argv[0]);
ptt->type = (apr_int32_t)apr_atoi64(argv[1]);
ptt->level_max = (apr_int32_t)apr_atoi64(argv[5]);
ptt->cast_cycle = (apr_int32_t)apr_atoi64(argv[6]);
ptt->cast_round = (apr_int32_t)apr_atoi64(argv[7]);
ptt->cast_target = (apr_int32_t)apr_atoi64(argv[8]);
ptt->target_scope = (apr_int32_t)apr_atoi64(argv[9]);
ptt->att_type = (apr_int32_t)apr_atoi64(argv[10]);
ptt->base_fix_base = (apr_int32_t)apr_atoi64(argv[11]);
ptt->levelup_fix_base = (apr_int32_t)apr_atoi64(argv[12]);
ptt->levelup_prob = (apr_int32_t)apr_atoi64(argv[13]);
ptt->effect_type = (apr_int32_t)apr_atoi64(argv[14]);
ptt->effect_param = (apr_int32_t)apr_atoi64(argv[15]);
initskill_id_t key = ptt->id;
if (apr_hash_get(res_subhash, &key, sizeof(key)) == NULL) {
apr_hash_set(res_subhash, &key, sizeof(key), ptt);
} else {
fprintf(stderr,
"[RES] FAULT: duplicate key = %d\n",
key);
}
return APR_SUCCESS;
}
static void parse_command_line(int argc, const char* const argv[])
{
apr_getopt_t* os;
int ch;
const char* arg;
const char* bin_start = NULL;
int e;
static apr_getopt_option_t option[] =
{
{ NULL, '?', 0, "print help screen" },
{ NULL, 'v', 1, "verbose" },
{ NULL, 'D', 0, "debug mode" },
{ NULL, 'l', 1, "log directory" },
{ NULL, 'm', 1, "max log size" },
{ NULL, 't', 1, "terminate timeout" },
{ NULL, 'a', 0, "iterator aggregate" },
{ NULL, 'i', 0, "ignore qexec packet" },
{ NULL, 0, 0, NULL } };
apr_pool_t* pool;
if (0 != (e = apr_pool_create_alloc(&pool, 0)))
{
gpsmon_fatalx(FLINE, e, "apr_pool_create_alloc failed");
}
bin_start = argv[0] + strlen(argv[0]) - 1;
while (bin_start != argv[0] && *bin_start != '/')
bin_start--;
if (bin_start[0] == '/')
bin_start++;
opt.pname = bin_start;
opt.v = opt.D = 0;
opt.max_log_size = 0;
opt.terminate_timeout = 0;
if (0 != (e = apr_getopt_init(&os, pool, argc, argv)))
{
gpsmon_fatalx(FLINE, e, "apr_getopt_init failed");
}
while (0 == (e = apr_getopt_long(os, option, &ch, &arg)))
{
switch (ch)
{
case '?':
usage(0);
break;
case 'v':
opt.v = atoi(arg);
break;
case 'D':
opt.D = 1;
break;
case 'l':
opt.log_dir = strdup(arg);
break;
case 'm':
opt.max_log_size = apr_atoi64(arg);
break;
case 't':
opt.terminate_timeout = apr_atoi64(arg);
break;
}
}
if (e != APR_EOF)
usage("Error: illegal arguments");
if (os->ind >= argc)
usage("Error: missing port argument");
opt.arg_port = argv[os->ind++];
apr_pool_destroy(pool);
verbose = opt.v;
very_verbose = opt.V;
}
static apr_status_t dbd_mysql_datum_get(const apr_dbd_row_t *row, int n,
apr_dbd_type_e type, void *data)
{
if (row->res->statement) {
MYSQL_BIND *bind = &row->res->bind[n];
unsigned long len = *bind->length;
if (mysql_stmt_fetch_column(row->res->statement, bind, n, 0) != 0) {
return APR_EGENERAL;
}
if (*bind->is_null) {
return APR_ENOENT;
}
switch (type) {
case APR_DBD_TYPE_TINY:
*(char*)data = atoi(bind->buffer);
break;
case APR_DBD_TYPE_UTINY:
*(unsigned char*)data = atoi(bind->buffer);
break;
case APR_DBD_TYPE_SHORT:
*(short*)data = atoi(bind->buffer);
break;
case APR_DBD_TYPE_USHORT:
*(unsigned short*)data = atoi(bind->buffer);
break;
case APR_DBD_TYPE_INT:
*(int*)data = atoi(bind->buffer);
break;
case APR_DBD_TYPE_UINT:
*(unsigned int*)data = atoi(bind->buffer);
break;
case APR_DBD_TYPE_LONG:
*(long*)data = atol(bind->buffer);
break;
case APR_DBD_TYPE_ULONG:
*(unsigned long*)data = atol(bind->buffer);
break;
case APR_DBD_TYPE_LONGLONG:
*(apr_int64_t*)data = apr_atoi64(bind->buffer);
break;
case APR_DBD_TYPE_ULONGLONG:
*(apr_uint64_t*)data = apr_atoi64(bind->buffer);
break;
case APR_DBD_TYPE_FLOAT:
*(float*)data = (float) atof(bind->buffer);
break;
case APR_DBD_TYPE_DOUBLE:
*(double*)data = atof(bind->buffer);
break;
case APR_DBD_TYPE_STRING:
case APR_DBD_TYPE_TEXT:
case APR_DBD_TYPE_TIME:
case APR_DBD_TYPE_DATE:
case APR_DBD_TYPE_DATETIME:
case APR_DBD_TYPE_TIMESTAMP:
case APR_DBD_TYPE_ZTIMESTAMP:
*((char*)bind->buffer+bind->buffer_length-1) = '\0';
*(char**)data = bind->buffer;
break;
case APR_DBD_TYPE_BLOB:
case APR_DBD_TYPE_CLOB:
{
apr_bucket *e;
apr_bucket_brigade *b = (apr_bucket_brigade*)data;
e = apr_bucket_lob_create(row, n, 0, len,
row->res->pool, b->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(b, e);
}
break;
case APR_DBD_TYPE_NULL:
*(void**)data = NULL;
break;
default:
return APR_EGENERAL;
}
}
else {
if (row->row[n] == NULL) {
return APR_ENOENT;
}
switch (type) {
case APR_DBD_TYPE_TINY:
*(char*)data = atoi(row->row[n]);
break;
case APR_DBD_TYPE_UTINY:
*(unsigned char*)data = atoi(row->row[n]);
break;
case APR_DBD_TYPE_SHORT:
*(short*)data = atoi(row->row[n]);
break;
case APR_DBD_TYPE_USHORT:
*(unsigned short*)data = atoi(row->row[n]);
break;
case APR_DBD_TYPE_INT:
*(int*)data = atoi(row->row[n]);
break;
case APR_DBD_TYPE_UINT:
*(unsigned int*)data = atoi(row->row[n]);
break;
case APR_DBD_TYPE_LONG:
*(long*)data = atol(row->row[n]);
break;
case APR_DBD_TYPE_ULONG:
*(unsigned long*)data = atol(row->row[n]);
break;
case APR_DBD_TYPE_LONGLONG:
*(apr_int64_t*)data = apr_atoi64(row->row[n]);
break;
case APR_DBD_TYPE_ULONGLONG:
*(apr_uint64_t*)data = apr_atoi64(row->row[n]);
break;
case APR_DBD_TYPE_FLOAT:
*(float*)data = (float) atof(row->row[n]);
break;
case APR_DBD_TYPE_DOUBLE:
*(double*)data = atof(row->row[n]);
break;
case APR_DBD_TYPE_STRING:
case APR_DBD_TYPE_TEXT:
case APR_DBD_TYPE_TIME:
case APR_DBD_TYPE_DATE:
case APR_DBD_TYPE_DATETIME:
case APR_DBD_TYPE_TIMESTAMP:
case APR_DBD_TYPE_ZTIMESTAMP:
*(char**)data = row->row[n];
break;
case APR_DBD_TYPE_BLOB:
case APR_DBD_TYPE_CLOB:
{
apr_bucket *e;
apr_bucket_brigade *b = (apr_bucket_brigade*)data;
e = apr_bucket_pool_create(row->row[n], row->len[n],
row->res->pool, b->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(b, e);
}
break;
case APR_DBD_TYPE_NULL:
*(void**)data = NULL;
break;
default:
return APR_EGENERAL;
}
}
return 0;
}
/*
* main
*/
int main(int argc, const char * const argv[])
{
apr_off_t max;
apr_time_t current, repeat, delay, previous;
apr_status_t status;
apr_pool_t *pool, *instance;
apr_getopt_t *o;
apr_finfo_t info;
int retries, isdaemon, limit_found, intelligent, dowork;
char opt;
const char *arg;
char *proxypath, *path;
interrupted = 0;
repeat = 0;
isdaemon = 0;
dryrun = 0;
limit_found = 0;
max = 0;
verbose = 0;
realclean = 0;
benice = 0;
deldirs = 0;
intelligent = 0;
previous = 0; /* avoid compiler warning */
proxypath = NULL;
if (apr_app_initialize(&argc, &argv, NULL) != APR_SUCCESS) {
return 1;
}
atexit(apr_terminate);
if (argc) {
shortname = apr_filepath_name_get(argv[0]);
}
if (apr_pool_create(&pool, NULL) != APR_SUCCESS) {
return 1;
}
apr_pool_abort_set(oom, pool);
apr_file_open_stderr(&errfile, pool);
apr_signal(SIGINT, setterm);
apr_signal(SIGTERM, setterm);
apr_getopt_init(&o, pool, argc, argv);
while (1) {
status = apr_getopt(o, "iDnvrtd:l:L:p:", &opt, &arg);
if (status == APR_EOF) {
break;
}
else if (status != APR_SUCCESS) {
usage();
}
else {
switch (opt) {
case 'i':
if (intelligent) {
usage();
}
intelligent = 1;
break;
case 'D':
if (dryrun) {
usage();
}
dryrun = 1;
break;
case 'n':
if (benice) {
usage();
}
benice = 1;
break;
case 't':
if (deldirs) {
usage();
}
deldirs = 1;
break;
case 'v':
if (verbose) {
usage();
}
verbose = 1;
break;
case 'r':
if (realclean) {
usage();
}
realclean = 1;
deldirs = 1;
break;
case 'd':
if (isdaemon) {
usage();
}
isdaemon = 1;
repeat = apr_atoi64(arg);
repeat *= SECS_PER_MIN;
repeat *= APR_USEC_PER_SEC;
break;
case 'l':
if (limit_found) {
usage();
}
limit_found = 1;
do {
apr_status_t rv;
char *end;
rv = apr_strtoff(&max, arg, &end, 10);
if (rv == APR_SUCCESS) {
if ((*end == 'K' || *end == 'k') && !end[1]) {
max *= KBYTE;
}
else if ((*end == 'M' || *end == 'm') && !end[1]) {
max *= MBYTE;
}
else if ((*end == 'G' || *end == 'g') && !end[1]) {
max *= GBYTE;
}
else if (*end && /* neither empty nor [Bb] */
((*end != 'B' && *end != 'b') || end[1])) {
rv = APR_EGENERAL;
}
}
if (rv != APR_SUCCESS) {
apr_file_printf(errfile, "Invalid limit: %s"
APR_EOL_STR APR_EOL_STR, arg);
usage();
}
} while(0);
break;
case 'p':
if (proxypath) {
usage();
}
proxypath = apr_pstrdup(pool, arg);
if (apr_filepath_set(proxypath, pool) != APR_SUCCESS) {
usage();
}
break;
} /* switch */
} /* else */
} /* while */
if (o->ind != argc) {
usage();
}
if (isdaemon && (repeat <= 0 || verbose || realclean || dryrun)) {
usage();
}
if (!isdaemon && intelligent) {
usage();
}
if (!proxypath || max <= 0) {
usage();
}
if (apr_filepath_get(&path, 0, pool) != APR_SUCCESS) {
usage();
}
baselen = strlen(path);
#ifndef DEBUG
if (isdaemon) {
apr_file_close(errfile);
apr_proc_detach(APR_PROC_DETACH_DAEMONIZE);
}
#endif
do {
apr_pool_create(&instance, pool);
now = apr_time_now();
APR_RING_INIT(&root, _entry, link);
delcount = 0;
unsolicited = 0;
dowork = 0;
switch (intelligent) {
case 0:
dowork = 1;
break;
case 1:
retries = STAT_ATTEMPTS;
status = APR_SUCCESS;
do {
if (status != APR_SUCCESS) {
apr_sleep(STAT_DELAY);
}
status = apr_stat(&info, path, APR_FINFO_MTIME, instance);
} while (status != APR_SUCCESS && !interrupted && --retries);
if (status == APR_SUCCESS) {
previous = info.mtime;
intelligent = 2;
}
dowork = 1;
break;
case 2:
retries = STAT_ATTEMPTS;
status = APR_SUCCESS;
do {
if (status != APR_SUCCESS) {
apr_sleep(STAT_DELAY);
}
status = apr_stat(&info, path, APR_FINFO_MTIME, instance);
} while (status != APR_SUCCESS && !interrupted && --retries);
if (status == APR_SUCCESS) {
if (previous != info.mtime) {
dowork = 1;
}
previous = info.mtime;
break;
}
intelligent = 1;
dowork = 1;
break;
}
if (dowork && !interrupted) {
if (!process_dir(path, instance) && !interrupted) {
purge(path, instance, max);
}
else if (!isdaemon && !interrupted) {
apr_file_printf(errfile, "An error occurred, cache cleaning "
"aborted." APR_EOL_STR);
return 1;
}
if (intelligent && !interrupted) {
retries = STAT_ATTEMPTS;
status = APR_SUCCESS;
do {
if (status != APR_SUCCESS) {
apr_sleep(STAT_DELAY);
}
status = apr_stat(&info, path, APR_FINFO_MTIME, instance);
} while (status != APR_SUCCESS && !interrupted && --retries);
if (status == APR_SUCCESS) {
previous = info.mtime;
intelligent = 2;
}
else {
intelligent = 1;
}
}
}
apr_pool_destroy(instance);
current = apr_time_now();
if (current < now) {
delay = repeat;
}
else if (current - now >= repeat) {
delay = repeat;
}
else {
delay = now + repeat - current;
}
/* we can't sleep the whole delay time here apiece as this is racy
* with respect to interrupt delivery - think about what happens
* if we have tested for an interrupt, then get scheduled
* before the apr_sleep() call and while waiting for the cpu
* we do get an interrupt
*/
if (isdaemon) {
while (delay && !interrupted) {
if (delay > APR_USEC_PER_SEC) {
apr_sleep(APR_USEC_PER_SEC);
delay -= APR_USEC_PER_SEC;
}
else {
apr_sleep(delay);
delay = 0;
}
}
}
} while (isdaemon && !interrupted);
if (!isdaemon && interrupted) {
apr_file_printf(errfile, "Cache cleaning aborted due to user "
"request." APR_EOL_STR);
return 1;
}
return 0;
}
static apr_status_t dbd_pgsql_datum_get(const apr_dbd_row_t *row, int n,
apr_dbd_type_e type, void *data)
{
if (PQgetisnull(row->res->res, row->n, n)) {
return APR_ENOENT;
}
switch (type) {
case APR_DBD_TYPE_TINY:
*(char*)data = atoi(PQgetvalue(row->res->res, row->n, n));
break;
case APR_DBD_TYPE_UTINY:
*(unsigned char*)data = atoi(PQgetvalue(row->res->res, row->n, n));
break;
case APR_DBD_TYPE_SHORT:
*(short*)data = atoi(PQgetvalue(row->res->res, row->n, n));
break;
case APR_DBD_TYPE_USHORT:
*(unsigned short*)data = atoi(PQgetvalue(row->res->res, row->n, n));
break;
case APR_DBD_TYPE_INT:
*(int*)data = atoi(PQgetvalue(row->res->res, row->n, n));
break;
case APR_DBD_TYPE_UINT:
*(unsigned int*)data = atoi(PQgetvalue(row->res->res, row->n, n));
break;
case APR_DBD_TYPE_LONG:
*(long*)data = atol(PQgetvalue(row->res->res, row->n, n));
break;
case APR_DBD_TYPE_ULONG:
*(unsigned long*)data = atol(PQgetvalue(row->res->res, row->n, n));
break;
case APR_DBD_TYPE_LONGLONG:
*(apr_int64_t*)data = apr_atoi64(PQgetvalue(row->res->res, row->n, n));
break;
case APR_DBD_TYPE_ULONGLONG:
*(apr_uint64_t*)data = apr_atoi64(PQgetvalue(row->res->res, row->n, n));
break;
case APR_DBD_TYPE_FLOAT:
*(float*)data = (float)atof(PQgetvalue(row->res->res, row->n, n));
break;
case APR_DBD_TYPE_DOUBLE:
*(double*)data = atof(PQgetvalue(row->res->res, row->n, n));
break;
case APR_DBD_TYPE_STRING:
case APR_DBD_TYPE_TEXT:
case APR_DBD_TYPE_TIME:
case APR_DBD_TYPE_DATE:
case APR_DBD_TYPE_DATETIME:
case APR_DBD_TYPE_TIMESTAMP:
case APR_DBD_TYPE_ZTIMESTAMP:
*(char**)data = PQgetvalue(row->res->res, row->n, n);
break;
case APR_DBD_TYPE_BLOB:
case APR_DBD_TYPE_CLOB:
{
apr_bucket *e;
apr_bucket_brigade *b = (apr_bucket_brigade*)data;
e = apr_bucket_pool_create(PQgetvalue(row->res->res, row->n, n),
PQgetlength(row->res->res, row->n, n),
row->res->pool, b->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(b, e);
}
break;
case APR_DBD_TYPE_NULL:
*(void**)data = NULL;
break;
default:
return APR_EGENERAL;
}
return APR_SUCCESS;
}
void mag_check_session(request_rec *req,
struct mag_config *cfg, struct mag_conn **conn)
{
struct mag_conn *mc;
apr_status_t rc;
session_rec *sess = NULL;
const char *sessval = NULL;
int declen;
struct databuf ctxbuf = { 0 };
struct databuf cipherbuf = { 0 };
char *next, *last;
time_t expiration;
rc = mag_session_load(req, &sess);
if (rc != OK || sess == NULL) {
ap_log_rerror(APLOG_MARK, APLOG_INFO|APLOG_NOERRNO, 0, req,
"Sessions not available, no cookies!");
return;
}
mc = *conn;
if (!mc) {
mc = apr_pcalloc(req->pool, sizeof(struct mag_conn));
if (!mc) return;
mc->parent = req->pool;
*conn = mc;
}
rc = mag_session_get(req, sess, MAG_BEARER_KEY, &sessval);
if (rc != OK) {
ap_log_rerror(APLOG_MARK, APLOG_ERR|APLOG_NOERRNO, 0, req,
"Failed to get session data!");
return;
}
if (!sessval) {
/* no session established, just return */
return;
}
if (!cfg->mag_skey) {
ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, req,
"Session key not available, no cookies!");
/* we do not have a key, just return */
return;
}
/* decode it */
declen = apr_base64_decode_len(sessval);
cipherbuf.value = apr_palloc(req->pool, declen);
if (!cipherbuf.value) return;
cipherbuf.length = (int)apr_base64_decode((char *)cipherbuf.value, sessval);
rc = UNSEAL_BUFFER(req->pool, cfg->mag_skey, &cipherbuf, &ctxbuf);
if (rc != OK) {
ap_log_rerror(APLOG_MARK, APLOG_ERR|APLOG_NOERRNO, 0, req,
"Failed to unseal session data!");
return;
}
/* get time */
next = apr_strtok((char *)ctxbuf.value, ":", &last);
expiration = (time_t)apr_atoi64(next);
if (expiration < time(NULL)) {
/* credentials fully expired, return nothing */
return;
}
/* user name is next */
next = apr_strtok(NULL, ":", &last);
mc->user_name = apr_pstrdup(mc->parent, next);
if (!mc->user_name) return;
/* gssapi name (often a principal) is last.
* (because it may contain the separator as a valid char we
* just read last as is, without further tokenizing */
mc->gss_name = apr_pstrdup(mc->parent, last);
if (!mc->gss_name) return;
/* OK we have a valid token */
mc->established = true;
}