/*
* simple_table_update - replace a tuple
*
* This routine may be used to update a tuple when concurrent updates of
* the target tuple are not expected (for example, because we have a lock
* on the relation associated with the tuple). Any failure is reported
* via ereport().
*/
void
simple_table_update(Relation rel, ItemPointer otid,
TupleTableSlot *slot,
Snapshot snapshot,
bool *update_indexes)
{
TM_Result result;
TM_FailureData tmfd;
LockTupleMode lockmode;
result = table_update(rel, otid, slot,
GetCurrentCommandId(true),
snapshot, InvalidSnapshot,
true /* wait for commit */ ,
&tmfd, &lockmode, update_indexes);
switch (result)
{
case TM_SelfModified:
/* Tuple was already updated in current command? */
elog(ERROR, "tuple already updated by self");
break;
case TM_Ok:
/* done successfully */
break;
case TM_Updated:
elog(ERROR, "tuple concurrently updated");
break;
case TM_Deleted:
elog(ERROR, "tuple concurrently deleted");
break;
default:
elog(ERROR, "unrecognized table_update status: %u", result);
break;
}
}
/* Função para substituir na tabela, o valor associado à chave key.
* Devolve 0 (OK) ou -1 em caso de erros.
*/
int pable_update(struct ptable_t *ptable, char *key, struct data_t *value)
{
int result,size;
result = -1;
if(ptable->isOpen)
{
struct message_t *msg;
char *msg_buffer,*buffer;
result = table_update(ptable->table,key,value);
if(result == 0)
{
msg = (struct message_t*) malloc(sizeof(struct message_t));
msg->opcode = OC_UPDATE;
msg->c_type = CT_ENTRY;
msg->content.entry = entry_create(key,value);
size = message_to_buffer(msg,&msg_buffer);
//
free_message(msg);
//Alocar memoria
buffer = (char *) malloc(size+sizeof(uint16_t));
if(buffer == NULL)
{
perror("Out of memory");
return -1;
}
//Copiar o tamanho da mensagem
memcpy(buffer,&size,sizeof(uint16_t));
//Copiar a mensagem
memcpy(buffer+sizeof(uint16_t),msg_buffer,size);
//Escrever mensagem
if(pmanager_log(ptable->pmanager,buffer)==-1)
{
printf("Falha na escrita\n");
}
//Free(s)
free(buffer);
free(msg_buffer);
}
}
return result;
}
static void recv_unix(void)
{
UN_CTX ctx;
struct atmarp_req req;
int len,reply;
len = un_recv(&ctx,unix_sock,&req,sizeof(req));
if (len < 0) {
diag(COMPONENT,DIAG_ERROR,"recv_unix: %s",strerror(errno));
return;
}
if (len != sizeof(req)) {
diag(COMPONENT,DIAG_ERROR,"bad unix read: %d != %d",len,sizeof(req));
return;
}
switch (req.type) {
case art_create:
reply = ioctl(kernel,SIOCMKCLIP,req.itf);
if (reply >= 0) itf_create(reply);
break;
case art_qos:
case art_set:
case art_delete:
reply = arp_ioctl(&req);
break;
case art_table:
reply = table_update();
break;
case art_query:
query_ip(&ctx,req.ip);
return;
default:
diag(COMPONENT,DIAG_ERROR,"invalid request msg type 0x%x",req.type);
reply = -EINVAL;
}
if (un_send(&ctx,&reply,sizeof(reply)) < 0)
diag(COMPONENT,DIAG_ERROR,"un_send: %s",strerror(errno));
}
int
main (int argc, char *argv[])
{
int table_bytes;
int lock_bytes;
int i;
srand ( getpid () + getuid () );
start_pes (0);
me = _my_pe ();
npes = _num_pes ();
/*
* size of the per-PE partition
*/
ip_pe = table_size / npes;
/*
* each PE only stores what it owns
*/
table_bytes = sizeof (*table) * ip_pe;
table = shmalloc (table_bytes); /* !!! unchecked !!! */
/*
* initialize table
*/
for (i = 0; i < ip_pe; i+= 1)
{
table[i] = 0;
}
/*
* each PE needs to be able to lock everywhere
*/
lock_bytes = sizeof (*lock) * table_size;
lock = shmalloc (lock_bytes); /* !!! unchecked !!! */
/*
* initialize locks
*/
for (i = 0; i < table_size; i+= 1)
{
lock[i] = 0L;
}
/*
* make sure all PEs have initialized symmetric data
*/
shmem_barrier_all ();
for (i = 0; i < 4; i += 1)
{
const int updater = rand () % npes;
if (me == updater)
{
const int i2u = rand () % table_size;
const int nv = rand () % 100;
printf ("PE %d: About to update index %d with %d...\n",
me, i2u, nv
);
table_update (nv, i2u);
}
}
shmem_barrier_all ();
/*
* everyone shows their part of the table
*/
table_dump ();
/*
* clean up allocated memory
*/
shmem_barrier_all ();
shfree (lock);
shfree (table);
return 0;
}
static void
lka_imsg(struct mproc *p, struct imsg *imsg)
{
struct rule *rule;
struct table *table;
void *tmp;
int ret;
const char *key, *val;
struct ssl *ssl;
struct iovec iov[3];
static struct dict *ssl_dict;
static struct dict *tables_dict;
static struct table *table_last;
static struct ca_vrfy_req_msg *req_ca_vrfy_smtp = NULL;
static struct ca_vrfy_req_msg *req_ca_vrfy_mta = NULL;
struct ca_vrfy_req_msg *req_ca_vrfy_chain;
struct ca_vrfy_resp_msg resp_ca_vrfy;
struct ca_cert_req_msg *req_ca_cert;
struct ca_cert_resp_msg resp_ca_cert;
struct sockaddr_storage ss;
struct userinfo userinfo;
struct addrname addrname;
struct envelope evp;
struct msg m;
union lookup lk;
char buf[SMTPD_MAXLINESIZE];
const char *tablename, *username, *password, *label;
uint64_t reqid;
size_t i;
int v;
if (imsg->hdr.type == IMSG_DNS_HOST ||
imsg->hdr.type == IMSG_DNS_PTR ||
imsg->hdr.type == IMSG_DNS_MX ||
imsg->hdr.type == IMSG_DNS_MX_PREFERENCE) {
dns_imsg(p, imsg);
return;
}
if (p->proc == PROC_SMTP) {
switch (imsg->hdr.type) {
case IMSG_LKA_EXPAND_RCPT:
m_msg(&m, imsg);
m_get_id(&m, &reqid);
m_get_envelope(&m, &evp);
m_end(&m);
lka_session(reqid, &evp);
return;
case IMSG_LKA_SSL_INIT:
req_ca_cert = imsg->data;
resp_ca_cert.reqid = req_ca_cert->reqid;
ssl = dict_get(env->sc_ssl_dict, req_ca_cert->name);
if (ssl == NULL) {
resp_ca_cert.status = CA_FAIL;
m_compose(p, IMSG_LKA_SSL_INIT, 0, 0, -1, &resp_ca_cert,
sizeof(resp_ca_cert));
return;
}
resp_ca_cert.status = CA_OK;
resp_ca_cert.cert_len = ssl->ssl_cert_len;
resp_ca_cert.key_len = ssl->ssl_key_len;
iov[0].iov_base = &resp_ca_cert;
iov[0].iov_len = sizeof(resp_ca_cert);
iov[1].iov_base = ssl->ssl_cert;
iov[1].iov_len = ssl->ssl_cert_len;
iov[2].iov_base = ssl->ssl_key;
iov[2].iov_len = ssl->ssl_key_len;
m_composev(p, IMSG_LKA_SSL_INIT, 0, 0, -1, iov, nitems(iov));
return;
case IMSG_LKA_SSL_VERIFY_CERT:
req_ca_vrfy_smtp = xmemdup(imsg->data, sizeof *req_ca_vrfy_smtp, "lka:ca_vrfy");
if (req_ca_vrfy_smtp == NULL)
fatal(NULL);
req_ca_vrfy_smtp->cert = xmemdup((char *)imsg->data +
sizeof *req_ca_vrfy_smtp, req_ca_vrfy_smtp->cert_len, "lka:ca_vrfy");
req_ca_vrfy_smtp->chain_cert = xcalloc(req_ca_vrfy_smtp->n_chain,
sizeof (unsigned char *), "lka:ca_vrfy");
req_ca_vrfy_smtp->chain_cert_len = xcalloc(req_ca_vrfy_smtp->n_chain,
sizeof (off_t), "lka:ca_vrfy");
return;
case IMSG_LKA_SSL_VERIFY_CHAIN:
if (req_ca_vrfy_smtp == NULL)
fatalx("lka:ca_vrfy: chain without a certificate");
req_ca_vrfy_chain = imsg->data;
req_ca_vrfy_smtp->chain_cert[req_ca_vrfy_smtp->chain_offset] = xmemdup((char *)imsg->data +
sizeof *req_ca_vrfy_chain, req_ca_vrfy_chain->cert_len, "lka:ca_vrfy");
req_ca_vrfy_smtp->chain_cert_len[req_ca_vrfy_smtp->chain_offset] = req_ca_vrfy_chain->cert_len;
req_ca_vrfy_smtp->chain_offset++;
return;
case IMSG_LKA_SSL_VERIFY:
if (req_ca_vrfy_smtp == NULL)
fatalx("lka:ca_vrfy: verify without a certificate");
resp_ca_vrfy.reqid = req_ca_vrfy_smtp->reqid;
if (! lka_X509_verify(req_ca_vrfy_smtp, CA_FILE, NULL))
resp_ca_vrfy.status = CA_FAIL;
else
resp_ca_vrfy.status = CA_OK;
m_compose(p, IMSG_LKA_SSL_VERIFY, 0, 0, -1, &resp_ca_vrfy,
sizeof resp_ca_vrfy);
for (i = 0; i < req_ca_vrfy_smtp->n_chain; ++i)
free(req_ca_vrfy_smtp->chain_cert[i]);
free(req_ca_vrfy_smtp->chain_cert);
free(req_ca_vrfy_smtp->chain_cert_len);
free(req_ca_vrfy_smtp->cert);
free(req_ca_vrfy_smtp);
return;
case IMSG_LKA_AUTHENTICATE:
m_msg(&m, imsg);
m_get_id(&m, &reqid);
m_get_string(&m, &tablename);
m_get_string(&m, &username);
m_get_string(&m, &password);
m_end(&m);
if (!tablename[0]) {
m_create(p_parent, IMSG_LKA_AUTHENTICATE,
0, 0, -1);
m_add_id(p_parent, reqid);
m_add_string(p_parent, username);
m_add_string(p_parent, password);
m_close(p_parent);
return;
}
ret = lka_authenticate(tablename, username, password);
m_create(p, IMSG_LKA_AUTHENTICATE, 0, 0, -1);
m_add_id(p, reqid);
m_add_int(p, ret);
m_close(p);
return;
}
}
if (p->proc == PROC_MDA) {
switch (imsg->hdr.type) {
case IMSG_LKA_USERINFO:
m_msg(&m, imsg);
m_get_string(&m, &tablename);
m_get_string(&m, &username);
m_end(&m);
ret = lka_userinfo(tablename, username, &userinfo);
m_create(p, IMSG_LKA_USERINFO, 0, 0, -1);
m_add_string(p, tablename);
m_add_string(p, username);
m_add_int(p, ret);
if (ret == LKA_OK)
m_add_data(p, &userinfo, sizeof(userinfo));
m_close(p);
return;
}
}
if (p->proc == PROC_MTA) {
switch (imsg->hdr.type) {
case IMSG_LKA_SSL_INIT:
req_ca_cert = imsg->data;
resp_ca_cert.reqid = req_ca_cert->reqid;
ssl = dict_get(env->sc_ssl_dict, req_ca_cert->name);
if (ssl == NULL) {
resp_ca_cert.status = CA_FAIL;
m_compose(p, IMSG_LKA_SSL_INIT, 0, 0, -1, &resp_ca_cert,
sizeof(resp_ca_cert));
return;
}
resp_ca_cert.status = CA_OK;
resp_ca_cert.cert_len = ssl->ssl_cert_len;
resp_ca_cert.key_len = ssl->ssl_key_len;
iov[0].iov_base = &resp_ca_cert;
iov[0].iov_len = sizeof(resp_ca_cert);
iov[1].iov_base = ssl->ssl_cert;
iov[1].iov_len = ssl->ssl_cert_len;
iov[2].iov_base = ssl->ssl_key;
iov[2].iov_len = ssl->ssl_key_len;
m_composev(p, IMSG_LKA_SSL_INIT, 0, 0, -1, iov, nitems(iov));
return;
case IMSG_LKA_SSL_VERIFY_CERT:
req_ca_vrfy_mta = xmemdup(imsg->data, sizeof *req_ca_vrfy_mta, "lka:ca_vrfy");
if (req_ca_vrfy_mta == NULL)
fatal(NULL);
req_ca_vrfy_mta->cert = xmemdup((char *)imsg->data +
sizeof *req_ca_vrfy_mta, req_ca_vrfy_mta->cert_len, "lka:ca_vrfy");
req_ca_vrfy_mta->chain_cert = xcalloc(req_ca_vrfy_mta->n_chain,
sizeof (unsigned char *), "lka:ca_vrfy");
req_ca_vrfy_mta->chain_cert_len = xcalloc(req_ca_vrfy_mta->n_chain,
sizeof (off_t), "lka:ca_vrfy");
return;
case IMSG_LKA_SSL_VERIFY_CHAIN:
if (req_ca_vrfy_mta == NULL)
fatalx("lka:ca_vrfy: verify without a certificate");
req_ca_vrfy_chain = imsg->data;
req_ca_vrfy_mta->chain_cert[req_ca_vrfy_mta->chain_offset] = xmemdup((char *)imsg->data +
sizeof *req_ca_vrfy_chain, req_ca_vrfy_chain->cert_len, "lka:ca_vrfy");
req_ca_vrfy_mta->chain_cert_len[req_ca_vrfy_mta->chain_offset] = req_ca_vrfy_chain->cert_len;
req_ca_vrfy_mta->chain_offset++;
return;
case IMSG_LKA_SSL_VERIFY:
if (req_ca_vrfy_mta == NULL)
fatalx("lka:ca_vrfy: verify without a certificate");
resp_ca_vrfy.reqid = req_ca_vrfy_mta->reqid;
if (! lka_X509_verify(req_ca_vrfy_mta, CA_FILE, NULL))
resp_ca_vrfy.status = CA_FAIL;
else
resp_ca_vrfy.status = CA_OK;
m_compose(p, IMSG_LKA_SSL_VERIFY, 0, 0, -1, &resp_ca_vrfy,
sizeof resp_ca_vrfy);
for (i = 0; i < req_ca_vrfy_mta->n_chain; ++i)
free(req_ca_vrfy_mta->chain_cert[i]);
free(req_ca_vrfy_mta->chain_cert);
free(req_ca_vrfy_mta->chain_cert_len);
free(req_ca_vrfy_mta->cert);
free(req_ca_vrfy_mta);
return;
case IMSG_LKA_SECRET:
m_msg(&m, imsg);
m_get_id(&m, &reqid);
m_get_string(&m, &tablename);
m_get_string(&m, &label);
m_end(&m);
lka_credentials(tablename, label, buf, sizeof(buf));
m_create(p, IMSG_LKA_SECRET, 0, 0, -1);
m_add_id(p, reqid);
m_add_string(p, buf);
m_close(p);
return;
case IMSG_LKA_SOURCE:
m_msg(&m, imsg);
m_get_id(&m, &reqid);
m_get_string(&m, &tablename);
table = table_find(tablename, NULL);
m_create(p, IMSG_LKA_SOURCE, 0, 0, -1);
m_add_id(p, reqid);
if (table == NULL) {
log_warn("warn: source address table %s missing",
tablename);
m_add_int(p, LKA_TEMPFAIL);
}
else {
ret = table_fetch(table, K_SOURCE, &lk);
if (ret == -1)
m_add_int(p, LKA_TEMPFAIL);
else if (ret == 0)
m_add_int(p, LKA_PERMFAIL);
else {
m_add_int(p, LKA_OK);
m_add_sockaddr(p,
(struct sockaddr *)&lk.source.addr);
}
}
m_close(p);
return;
case IMSG_LKA_HELO:
m_msg(&m, imsg);
m_get_id(&m, &reqid);
m_get_string(&m, &tablename);
m_get_sockaddr(&m, (struct sockaddr *)&ss);
m_end(&m);
ret = lka_addrname(tablename, (struct sockaddr*)&ss,
&addrname);
m_create(p, IMSG_LKA_HELO, 0, 0, -1);
m_add_id(p, reqid);
m_add_int(p, ret);
if (ret == LKA_OK)
m_add_string(p, addrname.name);
m_close(p);
return;
}
}
if (p->proc == PROC_PARENT) {
switch (imsg->hdr.type) {
case IMSG_CONF_START:
env->sc_rules_reload = xcalloc(1,
sizeof *env->sc_rules, "lka:sc_rules_reload");
tables_dict = xcalloc(1,
sizeof *tables_dict, "lka:tables_dict");
ssl_dict = calloc(1, sizeof *ssl_dict);
if (ssl_dict == NULL)
fatal(NULL);
dict_init(ssl_dict);
dict_init(tables_dict);
TAILQ_INIT(env->sc_rules_reload);
return;
case IMSG_CONF_SSL:
ssl = calloc(1, sizeof *ssl);
if (ssl == NULL)
fatal(NULL);
*ssl = *(struct ssl *)imsg->data;
ssl->ssl_cert = xstrdup((char *)imsg->data +
sizeof *ssl, "smtp:ssl_cert");
ssl->ssl_key = xstrdup((char *)imsg->data +
sizeof *ssl + ssl->ssl_cert_len, "smtp:ssl_key");
if (ssl->ssl_dhparams_len) {
ssl->ssl_dhparams = xstrdup((char *)imsg->data
+ sizeof *ssl + ssl->ssl_cert_len +
ssl->ssl_key_len, "smtp:ssl_dhparams");
}
if (ssl->ssl_ca_len) {
ssl->ssl_ca = xstrdup((char *)imsg->data
+ sizeof *ssl + ssl->ssl_cert_len +
ssl->ssl_key_len + ssl->ssl_dhparams_len,
"smtp:ssl_ca");
}
dict_set(ssl_dict, ssl->ssl_name, ssl);
return;
case IMSG_CONF_RULE:
rule = xmemdup(imsg->data, sizeof *rule, "lka:rule");
TAILQ_INSERT_TAIL(env->sc_rules_reload, rule, r_entry);
return;
case IMSG_CONF_TABLE:
table_last = table = xmemdup(imsg->data, sizeof *table,
"lka:table");
dict_init(&table->t_dict);
dict_set(tables_dict, table->t_name, table);
return;
case IMSG_CONF_RULE_SOURCE:
rule = TAILQ_LAST(env->sc_rules_reload, rulelist);
tmp = env->sc_tables_dict;
env->sc_tables_dict = tables_dict;
rule->r_sources = table_find(imsg->data, NULL);
if (rule->r_sources == NULL)
fatalx("lka: tables inconsistency");
env->sc_tables_dict = tmp;
return;
case IMSG_CONF_RULE_SENDER:
rule = TAILQ_LAST(env->sc_rules_reload, rulelist);
tmp = env->sc_tables_dict;
env->sc_tables_dict = tables_dict;
rule->r_senders = table_find(imsg->data, NULL);
if (rule->r_senders == NULL)
fatalx("lka: tables inconsistency");
env->sc_tables_dict = tmp;
return;
case IMSG_CONF_RULE_DESTINATION:
rule = TAILQ_LAST(env->sc_rules_reload, rulelist);
tmp = env->sc_tables_dict;
env->sc_tables_dict = tables_dict;
rule->r_destination = table_find(imsg->data, NULL);
if (rule->r_destination == NULL)
fatalx("lka: tables inconsistency");
env->sc_tables_dict = tmp;
return;
case IMSG_CONF_RULE_MAPPING:
rule = TAILQ_LAST(env->sc_rules_reload, rulelist);
tmp = env->sc_tables_dict;
env->sc_tables_dict = tables_dict;
rule->r_mapping = table_find(imsg->data, NULL);
if (rule->r_mapping == NULL)
fatalx("lka: tables inconsistency");
env->sc_tables_dict = tmp;
return;
case IMSG_CONF_RULE_USERS:
rule = TAILQ_LAST(env->sc_rules_reload, rulelist);
tmp = env->sc_tables_dict;
env->sc_tables_dict = tables_dict;
rule->r_userbase = table_find(imsg->data, NULL);
if (rule->r_userbase == NULL)
fatalx("lka: tables inconsistency");
env->sc_tables_dict = tmp;
return;
case IMSG_CONF_TABLE_CONTENT:
table = table_last;
if (table == NULL)
fatalx("lka: tables inconsistency");
key = imsg->data;
if (table->t_type == T_HASH)
val = key + strlen(key) + 1;
else
val = NULL;
dict_set(&table->t_dict, key,
val ? xstrdup(val, "lka:dict_set") : NULL);
return;
case IMSG_CONF_END:
if (env->sc_rules)
purge_config(PURGE_RULES);
if (env->sc_tables_dict) {
table_close_all();
purge_config(PURGE_TABLES);
}
env->sc_rules = env->sc_rules_reload;
env->sc_ssl_dict = ssl_dict;
env->sc_tables_dict = tables_dict;
if (verbose & TRACE_TABLES)
table_dump_all();
table_open_all();
ssl_dict = NULL;
table_last = NULL;
tables_dict = NULL;
/* Start fulfilling requests */
mproc_enable(p_mda);
mproc_enable(p_mta);
mproc_enable(p_smtp);
return;
case IMSG_CTL_VERBOSE:
m_msg(&m, imsg);
m_get_int(&m, &v);
m_end(&m);
log_verbose(v);
return;
case IMSG_CTL_PROFILE:
m_msg(&m, imsg);
m_get_int(&m, &v);
m_end(&m);
profiling = v;
return;
case IMSG_PARENT_FORWARD_OPEN:
lka_session_forward_reply(imsg->data, imsg->fd);
return;
case IMSG_LKA_AUTHENTICATE:
m_forward(p_smtp, imsg);
return;
}
}
if (p->proc == PROC_CONTROL) {
switch (imsg->hdr.type) {
case IMSG_LKA_UPDATE_TABLE:
table = table_find(imsg->data, NULL);
if (table == NULL) {
log_warnx("warn: Lookup table not found: "
"\"%s\"", (char *)imsg->data);
return;
}
table_update(table);
return;
}
}
errx(1, "lka_imsg: unexpected %s imsg", imsg_to_str(imsg->hdr.type));
}
/**
* Mark as useful all disjuncts involved in some way to complete the
* structure within the current region. Note that only disjuncts
* strictly between lw and rw will be marked. If it so happens that
* this region itself is not valid, then this fact will be recorded
* in the table, and nothing else happens.
*/
static void mark_region(Sentence sent,
int lw, int rw, Connector *le, Connector *re)
{
Disjunct * d;
int left_valid, right_valid, i;
int start_word, end_word;
int w;
Match_node * m, *m1;
count_context_t *ctxt = sent->count_ctxt;
i = region_valid(sent, lw, rw, le, re);
if ((i==0) || (i==2)) return;
/* we only reach this point if it's a valid unmarked region, i=1 */
table_update(ctxt, lw, rw, le, re, 0, 2);
if ((le == NULL) && (re == NULL) && (ctxt->null_links) && (rw != 1+lw)) {
w = lw+1;
for (d = ctxt->local_sent[w].d; d != NULL; d = d->next) {
if ((d->left == NULL) && region_valid(sent, w, rw, d->right, NULL)) {
d->marked = TRUE;
mark_region(sent, w, rw, d->right, NULL);
}
}
mark_region(sent, w, rw, NULL, NULL);
return;
}
if (le == NULL) {
start_word = lw+1;
} else {
start_word = le->word;
}
if (re == NULL) {
end_word = rw-1;
} else {
end_word = re->word;
}
for (w=start_word; w < end_word+1; w++) {
m1 = m = form_match_list(sent, w, le, lw, re, rw);
for (; m!=NULL; m=m->next) {
d = m->d;
/* mark_cost++;*/
left_valid = (((le != NULL) && (d->left != NULL) && x_prune_match(ctxt, le, d->left, lw, w)) &&
((region_valid(sent, lw, w, le->next, d->left->next)) ||
((le->multi) && region_valid(sent, lw, w, le, d->left->next)) ||
((d->left->multi) && region_valid(sent, lw, w, le->next, d->left)) ||
((le->multi && d->left->multi) && region_valid(sent, lw, w, le, d->left))));
right_valid = (((d->right != NULL) && (re != NULL) && x_prune_match(ctxt, d->right, re, w, rw)) &&
((region_valid(sent, w, rw, d->right->next,re->next)) ||
((d->right->multi) && region_valid(sent, w,rw,d->right,re->next)) ||
((re->multi) && region_valid(sent, w, rw, d->right->next, re)) ||
((d->right->multi && re->multi) && region_valid(sent, w, rw, d->right, re))));
/* The following if statements could be restructured to avoid superfluous calls
to mark_region. It didn't seem a high priority, so I didn't optimize this.
*/
if (left_valid && region_valid(sent, w, rw, d->right, re)) {
d->marked = TRUE;
mark_region(sent, w, rw, d->right, re);
mark_region(sent, lw, w, le->next, d->left->next);
if (le->multi) mark_region(sent, lw, w, le, d->left->next);
if (d->left->multi) mark_region(sent, lw, w, le->next, d->left);
if (le->multi && d->left->multi) mark_region(sent, lw, w, le, d->left);
}
if (right_valid && region_valid(sent, lw, w, le, d->left)) {
d->marked = TRUE;
mark_region(sent, lw, w, le, d->left);
mark_region(sent, w, rw, d->right->next,re->next);
if (d->right->multi) mark_region(sent, w,rw,d->right,re->next);
if (re->multi) mark_region(sent, w, rw, d->right->next, re);
if (d->right->multi && re->multi) mark_region(sent, w, rw, d->right, re);
}
if (left_valid && right_valid) {
d->marked = TRUE;
mark_region(sent, lw, w, le->next, d->left->next);
if (le->multi) mark_region(sent, lw, w, le, d->left->next);
if (d->left->multi) mark_region(sent, lw, w, le->next, d->left);
if (le->multi && d->left->multi) mark_region(sent, lw, w, le, d->left);
mark_region(sent, w, rw, d->right->next,re->next);
if (d->right->multi) mark_region(sent, w,rw,d->right,re->next);
if (re->multi) mark_region(sent, w, rw, d->right->next, re);
if (d->right->multi && re->multi) mark_region(sent, w, rw, d->right, re);
}
}
put_match_list(sent, m1);
}
}
mysql::Binary_log_event *process_event(mysql::Binary_log_event *event) {
if (event->get_event_type() != mysql::USER_DEFINED)
return event;
std::cout << "Replay: Event type: [" << mysql::system::get_event_type_str(event->get_event_type())
<< "] length: " << event->header()->event_length
<< " next pos: " << event->header()->next_position
<< std::endl;
mysql::Transaction_log_event *trans = static_cast<mysql::Transaction_log_event *>(event);
int row_count = 0;
/*
The transaction event we created has aggregated all row events in an
ordered list.
*/
std::list<Binary_log_event *>::iterator it = (trans->m_events).begin();
mysql::Binary_log_event *event1;
for (; it != (trans->m_events).end(); ++it) {
event1 = *it;
std::cout << "transaction log event!! [" << event->get_event_type() << "], binlogev_type ["
<< event1->get_event_type() << "]\n";
switch (event1->get_event_type()) {
case mysql::WRITE_ROWS_EVENT:
case mysql::WRITE_ROWS_EVENT_V1:
case mysql::DELETE_ROWS_EVENT:
case mysql::DELETE_ROWS_EVENT_V1:
case mysql::UPDATE_ROWS_EVENT:
case mysql::UPDATE_ROWS_EVENT_V1:
std::cout << "transaction log event[write/delete/update]!!\n";
mysql::Row_event *rev = static_cast<mysql::Row_event *>(event1);
uint64_t table_id = rev->table_id;
Int_to_Event_map::iterator tm_it = trans->table_map().find(table_id);
if (tm_it != trans->table_map().end()) {
std::cout << "transaction log event!![TABLE_ID FOUND]\n";
Binary_log_event *tmevent = tm_it->second;
assert(tmevent != NULL);
mysql::Table_map_event *tm = static_cast<mysql::Table_map_event *>(tmevent);
/*
Each row event contains multiple rows and fields. The Row_iterator
allows us to iterate one row at a time.
*/
mysql::Row_event_set rows(rev, tm);
/*
Create a fully qualified table name
*/
std::ostringstream os;
os << tm->db_name << '.' << tm->table_name;
std::cout << "transaction log event!![TABLE is " << os.str() << "]\n";
try {
mysql::Row_event_set::iterator it = rows.begin();
std::cout << "transaction log event!![after rows.begin]\n";
do {
mysql::Row_of_fields fields = *it;
if (event1->get_event_type() == mysql::WRITE_ROWS_EVENT ||
event1->get_event_type() == mysql::WRITE_ROWS_EVENT_V1) {
std::cout << "transaction log event!![WRITE]\n";
table_insert(os.str(), fields);
}
if (event1->get_event_type() == mysql::UPDATE_ROWS_EVENT ||
event1->get_event_type() == mysql::UPDATE_ROWS_EVENT_V1) {
++it;
mysql::Row_of_fields fields2 = *it;
std::cout << "transaction log event!![UPDATE]\n";
table_update(os.str(), fields, fields2);
}
if (event1->get_event_type() == mysql::DELETE_ROWS_EVENT ||
event1->get_event_type() == mysql::DELETE_ROWS_EVENT_V1) {
std::cout << "transaction log event!![DELETE]\n";
table_delete(os.str(), fields);
}
} while (++it != rows.end());
}
catch (const std::logic_error &le) {
std::cout << "MySQL Data Type error: " << le.what() << '\n';
}
catch (std::exception const& ex) {
std::cout << "transaction log event error: " << ex.what() << "\n";
}
}
else {
std::cout << "Table id " << table_id
<< " was not registered by any preceding table map event."
<< std::endl;
continue;
}
}
}
/* Consume the event */
delete trans;
return 0;
}
