void RequestProcessor::process_callback(int rcode, PacketWrapper *wrapper)
{
log_debug("callback invoked from cluster %s, reference count: %d",
wrapper->get_group()->get_cluster_name().c_str(),
wrapper->get_request_reference_count());
TairGroup *group = wrapper->get_group();
//change request's status, if dataserver returns the failed `rcode.
//should change the request status.
if (rcode == TAIR_RETURN_SUCCESS || rcode == TAIR_RETURN_DATA_NOT_EXIST || rcode == DATA_EXPIRED)
{
log_debug("request committed to cluster %s success, rcode; %d",
group->get_cluster_name().c_str(), rcode);
if (wrapper->get_request_status() != COMMITTED_FAILED)
{
wrapper->set_request_status(COMMITTED_SUCCESS);
}
group->successed();
}
else
{
log_debug("request committed to cluster %s failed, rcode; %d",
group->get_cluster_name().c_str(), rcode);
wrapper->set_request_status(COMMITTED_FAILED);
if (rcode == TAIR_RETURN_TIMEOUT)
{
group->failed();
}
dump_key("callback_failed", wrapper->get_shared_info());
}
//release wrapper
log_debug("release wrapper by cluster %s", group->get_cluster_name().c_str());
delete wrapper;
}
isc_result_t
dns_tsigkeyring_dumpanddetach(dns_tsig_keyring_t **ringp, FILE *fp) {
isc_result_t result;
dns_rbtnodechain_t chain;
dns_name_t foundname;
dns_fixedname_t fixedorigin;
dns_name_t *origin;
isc_stdtime_t now;
dns_rbtnode_t *node;
dns_tsigkey_t *tkey;
dns_tsig_keyring_t *ring;
unsigned int references;
REQUIRE(ringp != NULL && *ringp != NULL);
ring = *ringp;
*ringp = NULL;
RWLOCK(&ring->lock, isc_rwlocktype_write);
INSIST(ring->references > 0);
ring->references--;
references = ring->references;
RWUNLOCK(&ring->lock, isc_rwlocktype_write);
if (references != 0)
return (DNS_R_CONTINUE);
isc_stdtime_get(&now);
dns_name_init(&foundname, NULL);
dns_fixedname_init(&fixedorigin);
origin = dns_fixedname_name(&fixedorigin);
dns_rbtnodechain_init(&chain, ring->mctx);
result = dns_rbtnodechain_first(&chain, ring->keys, &foundname,
origin);
if (result != ISC_R_SUCCESS && result != DNS_R_NEWORIGIN) {
dns_rbtnodechain_invalidate(&chain);
goto destroy;
}
for (;;) {
node = NULL;
dns_rbtnodechain_current(&chain, &foundname, origin, &node);
tkey = node->data;
if (tkey != NULL && tkey->generated && tkey->expire >= now)
dump_key(tkey, fp);
result = dns_rbtnodechain_next(&chain, &foundname,
origin);
if (result != ISC_R_SUCCESS && result != DNS_R_NEWORIGIN) {
dns_rbtnodechain_invalidate(&chain);
if (result == ISC_R_NOMORE)
result = ISC_R_SUCCESS;
goto destroy;
}
}
destroy:
destroyring(ring);
return (result);
}
void RequestProcessor::dump_key(const tair_dataentry_set &keyset, const char *msg) {
if (msg == NULL) {
msg = "error";
}
tair_dataentry_set::const_iterator it = keyset.begin();
while (it != keyset.end()) {
dump_key(**it, msg);
++it;
}
}
void RequestProcessor::do_process(PROCESS_RHS_FUNC_T pproc, MultiWrapper *wrapper)
{
tair_client_impl *tair_client = wrapper->get_tair_client();
if (tair_client != NULL)
{
TairGroup *group = wrapper->get_group();
if ((tair_client->*pproc)(wrapper->get_packet()->area, *(wrapper->get_keys()),&failed_key_code_map,
client_callback_with_multi_keys, (void*)wrapper) != TAIR_RETURN_SUCCESS)
{
dump_key("failed_send_request", wrapper->get_shared_info());
log_debug("send request to cluster %s failed.",
wrapper->get_group()->get_cluster_name().c_str());
vector<std::string> servers;
tair_client_impl *client = wrapper->get_tair_client();
tair_dataentry_set *keys = wrapper->get_keys();
if (keys == NULL || keys->empty())
{
//bug: request without any key.
log_error("request without any key, cluster name: %s, group name: %s, pcode: %d",
wrapper->get_group()->get_cluster_name().c_str(),
wrapper->get_group()->get_group_name().c_str(), wrapper->get_packet()->getPCode());
}
else
{
client->get_server_with_key(**(keys->begin()), servers);
if (!servers.empty())
{
log_error("failed to send request to data server: %s, group name: %s",
servers[0].c_str(), wrapper->get_packet()->get_group_name());
}
wrapper->set_request_status(COMMITTED_FAILED);
}
//just release the wrapper
delete wrapper;
}
else
{
if (group != NULL)
{
log_debug("send request to cluster %s success.",
group->get_cluster_name().c_str());
}
}
}
else
{
//bug: should not be here.
log_error("wrapper without tair_client, cluster name: %s, group name: %s",
wrapper->get_group()->get_cluster_name().c_str(),
wrapper->get_group()->get_group_name().c_str());
delete wrapper;
}
}
void prof_pmk(char *essid)
{
TIME_STRUCT p1,p2;
char key[16][128];
unsigned char pmk_sol[16][40];
unsigned char pmk_fast[16][40];
int i,j;
for(i=0;i<16;i++)
{
strcpy(key[i],"atest");
key[i][0]+=i;
}
p1 = t_start();
for(i=0;i<16;i++)
calc_pmk(key[i],essid,pmk_sol[i]); //key값과 essid로부터 pmk 값을 계산함
t_end(&p1);
p2 = t_start();
calc_16pmk(key,essid,pmk_fast);
t_end(&p2);
//diff
for(i=0;i<16;i++)
{
if(memcmp(pmk_sol[i],pmk_fast[i],sizeof(pmk_sol[i])) != 0)
{
printf("* %d wrong case (key:%s)\n",i,key[i]);
dump_key("pmk_sol",pmk_sol[i],sizeof(pmk_sol[i]));
dump_key("pmk_fst",pmk_fast[i],sizeof(pmk_fast[i]));
}
}
printf("original : %0.2lf ms\n",t_get(p1)/1000);
printf("simd ver : %0.2lf ms\n",t_get(p2)/1000);
printf("performance : x%0.2lf\n",t_get(p1)/t_get(p2));
}
void digsig_init_pkey_internal(void)
{
int buf_size;
printk(KERN_DEBUG "digsig.keys_valid 0x%08x\n\n", digsig_keys.valid);
dump_key("n_key", digsig_keys.n_key, 130);
dump_key("e_key", digsig_keys.e_key, 5);
if (digsig_keys.valid != 1) {
printk(KERN_NOTICE "DIGSIG: no valid key, digsig security disabled\n");
return;
}
DSM_PRINT(DEBUG_SIGN, "Reading raw_public_key_n!\n");
/*
* key size in bits encoded in first two bytes, big endian.
* round key size up and convert to bytes.
* add two bytes for the size field
*/
buf_size = digsig_keys.n_key[0] << 8 | digsig_keys.n_key[1];
buf_size = (buf_size + 7)/8;
buf_size += 2;
printk(KERN_INFO "%s: n_key size %d\n", __FUNCTION__, buf_size);
digsig_public_key[0] =
mpi_read_from_buffer(digsig_keys.n_key, &buf_size, 0);
DSM_PRINT(DEBUG_SIGN, "Reading raw_public_key_e!\n");
buf_size = digsig_keys.e_key[0] << 8 | digsig_keys.e_key[1];
buf_size = (buf_size + 7)/8;
buf_size += 2;
printk(KERN_INFO "%s: e_key size %d\n", __FUNCTION__, buf_size);
digsig_public_key[1] =
mpi_read_from_buffer(digsig_keys.e_key, &buf_size, 0);
g_init = 1;
printk(KERN_NOTICE "DIGSIG: digsig security enabled\n");
}
void queue_pkt_open_commit_sig(struct peer *peer)
{
OpenCommitSig *s = tal(peer, OpenCommitSig);
open_commit_sig__init(s);
dump_tx("Creating sig for:", peer->them.commit->tx);
dump_key("Using key:", &peer->us.commitkey);
peer->them.commit->sig = tal(peer->them.commit,
struct bitcoin_signature);
peer->them.commit->sig->stype = SIGHASH_ALL;
peer_sign_theircommit(peer, peer->them.commit->tx,
&peer->them.commit->sig->sig);
s->sig = signature_to_proto(s, &peer->them.commit->sig->sig);
queue_pkt(peer, PKT__PKT_OPEN_COMMIT_SIG, s);
}
void RequestProcessor::end_request(PacketWrapper *wrapper)
{
if (dump_key_switch)
{
dump_key("end_request", wrapper->get_shared_info());
}
//if the request' status is COMMITTED_SUCCESS, to do nothing here.
if (wrapper->get_request_status() == COMMITTED_FAILED)
{
//retry request.
SharedInfo *old_shared = wrapper->get_shared_info();
request_inval_packet *req = old_shared->packet;
std::string ds = obtain_ds_addr(wrapper);
old_shared->packet = NULL;
int retry_times = old_shared->get_retry_times();
if (retry_times < InvalRetryThread::RETRY_COUNT)
{
log_error("REQUEST FAILED, RETRY, retry_times: %d, cluster name: %s, group name: %s, pcode: %d, ds: %s",
retry_times, wrapper->get_group()->get_cluster_name().c_str(),
wrapper->get_group()->get_group_name().c_str(), req->getPCode(), ds.c_str());
SharedInfo *new_shared = new SharedInfo(0, 0, req);
new_shared->set_retry_times(retry_times);
//request packet was released by `shared, while the request's status is equ. to COMMITTED_SUCCESS.
retry_thread->add_packet(new_shared, retry_times);
//`old_shared should not be released here, and it will be released by is wrapper.
}
//cache the request packet.
else
{
log_error("REQUEST FAILED, HOLD, cluster name: %s, group name: %s, pcode: %d, ds: %s",
wrapper->get_group()->get_cluster_name().c_str(), wrapper->get_group()->get_group_name().c_str(),
req->getPCode(), ds.c_str());
//change the `shared status, the request packet hold by `shared will not be released by disconstructor of `shared.
old_shared->set_request_status(CACHED_IN_STORAGE);
//statistic
TAIR_INVAL_STAT.statistcs(pcode_opname_map[req->getPCode()], std::string(req->group_name),
req->area, inval_area_stat::FINALLY_EXEC);
//cache request packet
request_storage->write_request(req);
}
}
}
void RequestProcessor::do_process(PROCESS_RH_FUNC_T pproc, SingleWrapper *wrapper)
{
tair_client_impl *tair_client = wrapper->get_tair_client();
if (tair_client != NULL)
{
TairGroup *group = wrapper->get_group();
if ((tair_client->*pproc)(wrapper->get_packet()->area, *(wrapper->get_key()),
client_callback_with_single_key, (void*)wrapper) != TAIR_RETURN_SUCCESS)
{
log_error("send request to cluster %s failed.",
group->get_cluster_name().c_str());
vector<std::string> servers;
tair_client->get_server_with_key(*(wrapper->get_key()), servers);
if (!servers.empty())
{
log_error("failed to send request to data server: %s, group name: %s",
servers[0].c_str(), group->get_group_name().c_str());
}
wrapper->set_request_status(COMMITTED_FAILED);
dump_key("failed_send_request", wrapper->get_shared_info());
delete wrapper;
}
else
{
if (group != NULL)
{
log_debug("send request to cluster %s success.",
group->get_cluster_name().c_str());
}
}
}
else
{
//bug: should not be here.
log_error("wrapper without tair_client, cluster name: %s, group name: %s",
wrapper->get_group()->get_cluster_name().c_str(),
wrapper->get_group()->get_group_name().c_str());
delete wrapper;
}
}
int main(int argc, char **argv) {
unsigned char sha1_digest[40]={0};
unsigned char ssid[8]={0},buf[8]={0},year,week,x1,x2,x3;
unsigned int keys = 0,ssidLen = 0,verbose = 0, opt = 0;
unsigned char *strId = NULL;
FILE *ofile = NULL;
unsigned int year_target = 0;
unsigned int year_max = 0;
SHA_CTX sha1_ctx;
if(argc > 1) {
while( (opt = getopt(argc, argv,"vuy:o:i:")) != -1) {
switch(opt) {
case 'i' :
strId = (unsigned char *)optarg;
break;
case 'o' :
if((ofile = fopen(optarg,"wb")) == NULL) {
fprintf(stderr,"\nCannot open %s for output.\n",optarg);
return(0);
}
break;
case 'v' :
verbose++;
break;
case 'u' :
// Hex 0x30 is the specific ascii byte ('0') for the UPC variant
serial[0] = 0x30;
serial[1] = 0x30;
break;
case 'y' :
sscanf(optarg, "%u", &year_target);
if(year_target >= 5 && year_target <= 10) {
break;
}
else {
fprintf(stderr, "Invalid year selected: %u\n", year_target);
usage(argv);
}
default:
usage(argv);
}
}
if(!strId) usage(argv);
if(!(ssidLen = str2ssid(ssid,strId))) usage(argv);
if(verbose)
fprintf(stdout,"Generating keys..please wait\n");
if (year_target) {
year = year_target;
year_max = year_target;
} else {
year = 5;
year_max = 10;
}
// generate values only for 2005 - 2010
for(;year <= year_max;year++) {
if(verbose)
fprintf(stdout,"Calculating keys for 20%02d...\n",year);
serial[2] = (year / 10) + 48;
serial[3] = (year % 10) + 48;
// 52 weeks of the year
for(week = 1;week <= 52;week++) {
serial[4] = (week / 10) + 48;
serial[5] = (week % 10) + 48;
for(x1 = 0;x1 < 36;x1++) {
serial[6] = hexmsb(charTable[x1]);
serial[7] = hexlsb(charTable[x1]);
for(x2 = 0;x2 < 36;x2++) {
serial[8] = hexmsb(charTable[x2]);
serial[9] = hexlsb(charTable[x2]);
for(x3 = 0;x3 < 36;x3++) {
serial[10] = hexmsb(charTable[x3]);
serial[11] = hexlsb(charTable[x3]);
// hash serial number with sha-1
SHA1_Init(&sha1_ctx);
SHA1_Update(&sha1_ctx,serial,SERIAL_LENGTH);
SHA1_Final(&sha1_ctx,sha1_digest);
// compare SSID octets with last number of bytes supplied
if(memcmp(&sha1_digest[(SHA1_LENGTH-ssidLen)],ssid,ssidLen) == 0) {
keys++;
if(verbose) {
memcpy(buf,serial,6);
fprintf(stdout,
"Serial Number Year 20%02d: %s**%C%C%C - potential key = ",year,
buf,charTable[x1],charTable[x2],charTable[x3]);
dump_key(stdout,sha1_digest);
} else {
dump_key(stdout,sha1_digest);
}
if(ofile) {
dump_key(ofile,sha1_digest);
}
}
}
}
}
}
}
if(verbose)
fprintf(stdout,"Found %d potential keys.\n",keys);
if(ofile) fclose(ofile);
}
else {
usage(argv);
}
return(0);
}
int
compute_key(char *strId, int year, char *output, int len) {
unsigned char sha1_digest[40]={0};
char ssid[8]={0},buf[8]={0},week,x1,x2,x3;
int keys = 0,ssidLen = 0;
int offset = 0;
if(!(ssidLen = str2ssid(ssid,strId)))
return -99;
//fprintf(stdout,"\nGenerating keys..please wait\n\n");
serial[3] = year | '0';
// 52 weeks of the year
for(week = 1;week <= 52;week++) {
serial[4] = (week / 10) + '0';
serial[5] = (week % 10) + '0';
for(x1 = 0;x1 < 36;x1++) {
serial[6] = hexmsb(charTable[x1]);
serial[7] = hexlsb(charTable[x1]);
for(x2 = 0;x2 < 36;x2++) {
serial[8] = hexmsb(charTable[x2]);
serial[9] = hexlsb(charTable[x2]);
for(x3 = 0;x3 < 36;x3++) {
serial[10] = hexmsb(charTable[x3]);
serial[11] = hexlsb(charTable[x3]);
// hash serial number with sha-1
CC_SHA1(serial, SERIAL_LENGTH, sha1_digest);
// compare SSID octets with last number of bytes supplied
if(memcmp(&sha1_digest[(20-ssidLen)],ssid,ssidLen) == 0) {
// check if more keys will fit in the provided buffer
if (keys >= len/(OUTPUT_KEY_SIZE))
goto __done;
keys++;
memcpy(buf,serial,6);
sprintf(&output[offset], "[%s**%C%C%C]: ", buf, charTable[x1],charTable[x2],charTable[x3]);
offset += OUTPUT_OVERHEAD;
dump_key(&output[offset],sha1_digest);
offset += DEFAULT_KEY_SIZE*2;
strcat(&output[offset], "\n");
output[++offset] = 0; // ensure to null-terminate the string
}
}
}
}
}
__done:
//fprintf(stdout,"\nFound %d potential keys.\n",keys);
return keys;
}
static void tlinit(void)
{
int rc, i;
char *Term = getenv("TERM");
if (Term == NULL) {
printf("FATAL ERROR: environment variable TERM not set.\n");
exit(1);
}
setupterm(Term, 1, &rc);
if (rc != 1) {
printf("FATAL ERROR: Unable to get terminfo entry for %s.\n",
Term);
exit(1);
}
if (!clear_screen || !clr_eol || !cursor_address) {
printf("FATAL ERROR: Terminfo entry for %s incomplete.\n",
Term);
exit(1);
}
if (!exit_attribute_mode)
enter_reverse_mode = enter_standout_mode = enter_bold_mode = NULL;
/* initialize the terminal */
TPUTS(init_1string);
TPUTS(init_2string);
TPUTS(init_3string);
set_tkey(0, key_up);
set_tkey(1, key_down);
set_tkey(2, key_right);
set_tkey(3, key_left);
set_tkey(4, key_ic);
set_tkey(5, key_dc);
set_tkey(6, key_ppage);
set_tkey(7, key_npage);
set_tkey(8, key_home);
set_tkey(9, key_end);
if (key_f0) { /* old school */
set_tkey(10, key_f0);
set_tkey(11, key_f1);
i = 12;
} else {
set_tkey(10, key_f1);
set_tkey(21, key_f12);
i = 11;
}
set_tkey(i++, key_f2);
set_tkey(i++, key_f3);
set_tkey(i++, key_f4);
set_tkey(i++, key_f5);
set_tkey(i++, key_f6);
set_tkey(i++, key_f7);
set_tkey(i++, key_f8);
set_tkey(i++, key_f9);
set_tkey(i++, key_f10);
set_tkey(i++, key_f11);
#ifdef SAM_NO
Key_mask = 0x00c00000; /* C-Home and C-End not in terminfo */
for (k = 0; k < i; ++k)
if (Tkeys[k] && *Tkeys[k])
Key_mask |= 1 << k;
if (verbose) {
for (k = 0; k < i; ++k)
dump_key(k, Tkeys[k], NULL);
Dbg("Key Mask %x\n", Key_mask);
}
#endif
}
