int main(int argc, char **argv)
{
int cf_index;
Octstr *type;
gwlib_init();
cf_index = get_and_set_debugs(argc, argv, check_args);
if (argv[cf_index] == NULL) {
debug("",0,"Usage: %s <store-file>", argv[0]);
goto error;
}
type = octstr_create("file");
/* init store subsystem */
store_init(type, octstr_imm(argv[cf_index]), -1, msg_pack, msg_unpack_wrapper);
/* pass every entry in the store to callback print_msg() */
store_load(print_msg);
info(0, "Store file contains %d msg entries", counter);
info(0, "Shutting down.");
error:
gwlib_shutdown();
return 1;
}
int main(int argc, char **argv) {
int32_t ch, index, excl_index;
const char *name;
bool load_default, exclusive;
load_default = true;
exclusive = false;
index = 0;
while (1) {
if ((ch = getopt_long_only(argc, argv, "", opt_field, &index)) < 0)
break;
switch (ch) {
case OPT_LOG:
log_load(optarg);
break;
case OPT_CONFIG:
config_load(optarg);
load_default = false;
break;
case OPT_EXCL:
if (exclusive)
error("Cannot use --%s with --%s",
opt_field[index].name,
opt_field[excl_index].name);
exclusive = true;
excl_index = index;
case OPT_NRML:
name = opt_field[index].name;
if (opt_field[index].has_arg)
config_set(name, optarg);
else
config_set(name, "true");
break;
case OPT_VERSION:
version();
return 1;
case OPT_HELP:
default:
usage();
return 1;
}
}
if (load_default)
config_default();
mt_init();
store_load();
bucket_load();
crypt_load();
volume_load();
return 0;
}
int main(int argc, char **argv)
{
int cf_index;
Cfg *cfg;
bb_status = BB_RUNNING;
gwlib_init();
start_time = time(NULL);
suspended = gwlist_create();
isolated = gwlist_create();
gwlist_add_producer(suspended);
gwlist_add_producer(isolated);
cf_index = get_and_set_debugs(argc, argv, check_args);
if (argv[cf_index] == NULL)
cfg_filename = octstr_create("kannel.conf");
else
cfg_filename = octstr_create(argv[cf_index]);
cfg = cfg_create(cfg_filename);
if (cfg_read(cfg) == -1)
panic(0, "Couldn't read configuration from `%s'.", octstr_get_cstr(cfg_filename));
dlr_init(cfg);
report_versions("bearerbox");
flow_threads = gwlist_create();
if (init_bearerbox(cfg) == NULL)
panic(0, "Initialization failed.");
info(0, "----------------------------------------");
info(0, GW_NAME " bearerbox II version %s starting", GW_VERSION);
gwthread_sleep(5.0); /* give time to threads to register themselves */
if (store_load(dispatch_into_queue) == -1)
panic(0, "Cannot start with store-file failing");
info(0, "MAIN: Start-up done, entering mainloop");
if (bb_status == BB_SUSPENDED) {
info(0, "Gateway is now SUSPENDED by startup arguments");
} else if (bb_status == BB_ISOLATED) {
info(0, "Gateway is now ISOLATED by startup arguments");
gwlist_remove_producer(suspended);
} else {
smsc2_resume(1);
gwlist_remove_producer(suspended);
gwlist_remove_producer(isolated);
}
while (bb_status != BB_SHUTDOWN && bb_status != BB_DEAD &&
gwlist_producer_count(flow_threads) > 0) {
/* debug("bb", 0, "Main Thread: going to sleep."); */
/*
* Not infinite sleep here, because we should notice
* when all "flow threads" are dead and shutting bearerbox
* down.
* XXX if all "flow threads" call gwthread_wakeup(MAIN_THREAD_ID),
* we can enter infinite sleep then.
*/
gwthread_sleep(10.0);
/* debug("bb", 0, "Main Thread: woken up."); */
if (bb_todo == 0) {
continue;
}
if (bb_todo & BB_LOGREOPEN) {
warning(0, "SIGHUP received, catching and re-opening logs");
log_reopen();
alog_reopen();
bb_todo = bb_todo & ~BB_LOGREOPEN;
}
if (bb_todo & BB_CHECKLEAKS) {
warning(0, "SIGQUIT received, reporting memory usage.");
gw_check_leaks();
bb_todo = bb_todo & ~BB_CHECKLEAKS;
}
}
if (bb_status == BB_SHUTDOWN || bb_status == BB_DEAD)
warning(0, "Killing signal or HTTP admin command received, shutting down...");
/* call shutdown */
bb_shutdown();
/* wait until flow threads exit */
while (gwlist_consume(flow_threads) != NULL)
;
info(0, "All flow threads have died, killing core");
bb_status = BB_DEAD;
httpadmin_stop();
boxc_cleanup();
smsc2_cleanup();
store_shutdown();
empty_msg_lists();
gwlist_destroy(flow_threads, NULL);
gwlist_destroy(suspended, NULL);
gwlist_destroy(isolated, NULL);
mutex_destroy(status_mutex);
alog_close(); /* if we have any */
bb_alog_shutdown();
cfg_destroy(cfg);
octstr_destroy(cfg_filename);
dlr_shutdown();
/* now really restart */
if (restart)
restart_box(argv);
gwlib_shutdown();
return 0;
}
static void DoubleBlockSHA256(const void* pin, void* pad, const void *pre, unsigned int thash[9][NPAR], const void *init)
{
unsigned int* In = (unsigned int*)pin;
unsigned int* Pad = (unsigned int*)pad;
unsigned int* hPre = (unsigned int*)pre;
unsigned int* hInit = (unsigned int*)init;
unsigned int /* i, j, */ k;
/* vectors used in calculation */
vector unsigned int w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15;
vector unsigned int T1;
vector unsigned int a, b, c, d, e, f, g, h;
vector unsigned int nonce, preNonce;
/* nonce offset for vector */
vector unsigned int offset = (vector unsigned int)(0, 1, 2, 3);
preNonce = vec_add((vector unsigned int)(In[3],In[3],In[3],In[3]), offset);
for(k = 0; k<NPAR; k+=4)
{
w0 = (vector unsigned int)(In[0],In[0],In[0],In[0]);
w1 = (vector unsigned int)(In[1],In[1],In[1],In[1]);
w2 = (vector unsigned int)(In[2],In[2],In[2],In[2]);
//w3 = (vector unsigned int)(In[3],In[3],In[3],In[3]); nonce will be later hacked into the hash
w4 = (vector unsigned int)(In[4],In[4],In[4],In[4]);
w5 = (vector unsigned int)(In[5],In[5],In[5],In[5]);
w6 = (vector unsigned int)(In[6],In[6],In[6],In[6]);
w7 = (vector unsigned int)(In[7],In[7],In[7],In[7]);
w8 = (vector unsigned int)(In[8],In[8],In[8],In[8]);
w9 = (vector unsigned int)(In[9],In[9],In[9],In[9]);
w10 = (vector unsigned int)(In[10],In[10],In[10],In[10]);
w11 = (vector unsigned int)(In[11],In[11],In[11],In[11]);
w12 = (vector unsigned int)(In[12],In[12],In[12],In[12]);
w13 = (vector unsigned int)(In[13],In[13],In[13],In[13]);
w14 = (vector unsigned int)(In[14],In[14],In[14],In[14]);
w15 = (vector unsigned int)(In[15],In[15],In[15],In[15]);
/* hack nonce into lowest byte of w3 */
nonce = vec_add(preNonce, (vector unsigned int)(k,k,k,k));
w3 = nonce;
//printf ("W3: %08vlx\n", w3);
a = (vector unsigned int)(hPre[0],hPre[0],hPre[0],hPre[0]);
b = (vector unsigned int)(hPre[1],hPre[1],hPre[1],hPre[1]);
c = (vector unsigned int)(hPre[2],hPre[2],hPre[2],hPre[2]);
d = (vector unsigned int)(hPre[3],hPre[3],hPre[3],hPre[3]);
e = (vector unsigned int)(hPre[4],hPre[4],hPre[4],hPre[4]);
f = (vector unsigned int)(hPre[5],hPre[5],hPre[5],hPre[5]);
g = (vector unsigned int)(hPre[6],hPre[6],hPre[6],hPre[6]);
h = (vector unsigned int)(hPre[7],hPre[7],hPre[7],hPre[7]);
SHA256ROUND(a, b, c, d, e, f, g, h, 0, w0);
SHA256ROUND(h, a, b, c, d, e, f, g, 1, w1);
SHA256ROUND(g, h, a, b, c, d, e, f, 2, w2);
SHA256ROUND(f, g, h, a, b, c, d, e, 3, w3);
SHA256ROUND(e, f, g, h, a, b, c, d, 4, w4);
SHA256ROUND(d, e, f, g, h, a, b, c, 5, w5);
SHA256ROUND(c, d, e, f, g, h, a, b, 6, w6);
SHA256ROUND(b, c, d, e, f, g, h, a, 7, w7);
SHA256ROUND(a, b, c, d, e, f, g, h, 8, w8);
SHA256ROUND(h, a, b, c, d, e, f, g, 9, w9);
SHA256ROUND(g, h, a, b, c, d, e, f, 10, w10);
SHA256ROUND(f, g, h, a, b, c, d, e, 11, w11);
SHA256ROUND(e, f, g, h, a, b, c, d, 12, w12);
SHA256ROUND(d, e, f, g, h, a, b, c, 13, w13);
SHA256ROUND(c, d, e, f, g, h, a, b, 14, w14);
SHA256ROUND(b, c, d, e, f, g, h, a, 15, w15);
w0 = add4(SIGMA1_256(w14), w9, SIGMA0_256(w1), w0);
SHA256ROUND(a, b, c, d, e, f, g, h, 16, w0);
w1 = add4(SIGMA1_256(w15), w10, SIGMA0_256(w2), w1);
SHA256ROUND(h, a, b, c, d, e, f, g, 17, w1);
w2 = add4(SIGMA1_256(w0), w11, SIGMA0_256(w3), w2);
SHA256ROUND(g, h, a, b, c, d, e, f, 18, w2);
w3 = add4(SIGMA1_256(w1), w12, SIGMA0_256(w4), w3);
SHA256ROUND(f, g, h, a, b, c, d, e, 19, w3);
w4 = add4(SIGMA1_256(w2), w13, SIGMA0_256(w5), w4);
SHA256ROUND(e, f, g, h, a, b, c, d, 20, w4);
w5 = add4(SIGMA1_256(w3), w14, SIGMA0_256(w6), w5);
SHA256ROUND(d, e, f, g, h, a, b, c, 21, w5);
w6 = add4(SIGMA1_256(w4), w15, SIGMA0_256(w7), w6);
SHA256ROUND(c, d, e, f, g, h, a, b, 22, w6);
w7 = add4(SIGMA1_256(w5), w0, SIGMA0_256(w8), w7);
SHA256ROUND(b, c, d, e, f, g, h, a, 23, w7);
w8 = add4(SIGMA1_256(w6), w1, SIGMA0_256(w9), w8);
SHA256ROUND(a, b, c, d, e, f, g, h, 24, w8);
w9 = add4(SIGMA1_256(w7), w2, SIGMA0_256(w10), w9);
SHA256ROUND(h, a, b, c, d, e, f, g, 25, w9);
w10 = add4(SIGMA1_256(w8), w3, SIGMA0_256(w11), w10);
SHA256ROUND(g, h, a, b, c, d, e, f, 26, w10);
w11 = add4(SIGMA1_256(w9), w4, SIGMA0_256(w12), w11);
SHA256ROUND(f, g, h, a, b, c, d, e, 27, w11);
w12 = add4(SIGMA1_256(w10), w5, SIGMA0_256(w13), w12);
SHA256ROUND(e, f, g, h, a, b, c, d, 28, w12);
w13 = add4(SIGMA1_256(w11), w6, SIGMA0_256(w14), w13);
SHA256ROUND(d, e, f, g, h, a, b, c, 29, w13);
w14 = add4(SIGMA1_256(w12), w7, SIGMA0_256(w15), w14);
SHA256ROUND(c, d, e, f, g, h, a, b, 30, w14);
w15 = add4(SIGMA1_256(w13), w8, SIGMA0_256(w0), w15);
SHA256ROUND(b, c, d, e, f, g, h, a, 31, w15);
w0 = add4(SIGMA1_256(w14), w9, SIGMA0_256(w1), w0);
SHA256ROUND(a, b, c, d, e, f, g, h, 32, w0);
w1 = add4(SIGMA1_256(w15), w10, SIGMA0_256(w2), w1);
SHA256ROUND(h, a, b, c, d, e, f, g, 33, w1);
w2 = add4(SIGMA1_256(w0), w11, SIGMA0_256(w3), w2);
SHA256ROUND(g, h, a, b, c, d, e, f, 34, w2);
w3 = add4(SIGMA1_256(w1), w12, SIGMA0_256(w4), w3);
SHA256ROUND(f, g, h, a, b, c, d, e, 35, w3);
w4 = add4(SIGMA1_256(w2), w13, SIGMA0_256(w5), w4);
SHA256ROUND(e, f, g, h, a, b, c, d, 36, w4);
w5 = add4(SIGMA1_256(w3), w14, SIGMA0_256(w6), w5);
SHA256ROUND(d, e, f, g, h, a, b, c, 37, w5);
w6 = add4(SIGMA1_256(w4), w15, SIGMA0_256(w7), w6);
SHA256ROUND(c, d, e, f, g, h, a, b, 38, w6);
w7 = add4(SIGMA1_256(w5), w0, SIGMA0_256(w8), w7);
SHA256ROUND(b, c, d, e, f, g, h, a, 39, w7);
w8 = add4(SIGMA1_256(w6), w1, SIGMA0_256(w9), w8);
SHA256ROUND(a, b, c, d, e, f, g, h, 40, w8);
w9 = add4(SIGMA1_256(w7), w2, SIGMA0_256(w10), w9);
SHA256ROUND(h, a, b, c, d, e, f, g, 41, w9);
w10 = add4(SIGMA1_256(w8), w3, SIGMA0_256(w11), w10);
SHA256ROUND(g, h, a, b, c, d, e, f, 42, w10);
w11 = add4(SIGMA1_256(w9), w4, SIGMA0_256(w12), w11);
SHA256ROUND(f, g, h, a, b, c, d, e, 43, w11);
w12 = add4(SIGMA1_256(w10), w5, SIGMA0_256(w13), w12);
SHA256ROUND(e, f, g, h, a, b, c, d, 44, w12);
w13 = add4(SIGMA1_256(w11), w6, SIGMA0_256(w14), w13);
SHA256ROUND(d, e, f, g, h, a, b, c, 45, w13);
w14 = add4(SIGMA1_256(w12), w7, SIGMA0_256(w15), w14);
SHA256ROUND(c, d, e, f, g, h, a, b, 46, w14);
w15 = add4(SIGMA1_256(w13), w8, SIGMA0_256(w0), w15);
SHA256ROUND(b, c, d, e, f, g, h, a, 47, w15);
w0 = add4(SIGMA1_256(w14), w9, SIGMA0_256(w1), w0);
SHA256ROUND(a, b, c, d, e, f, g, h, 48, w0);
w1 = add4(SIGMA1_256(w15), w10, SIGMA0_256(w2), w1);
SHA256ROUND(h, a, b, c, d, e, f, g, 49, w1);
w2 = add4(SIGMA1_256(w0), w11, SIGMA0_256(w3), w2);
SHA256ROUND(g, h, a, b, c, d, e, f, 50, w2);
w3 = add4(SIGMA1_256(w1), w12, SIGMA0_256(w4), w3);
SHA256ROUND(f, g, h, a, b, c, d, e, 51, w3);
w4 = add4(SIGMA1_256(w2), w13, SIGMA0_256(w5), w4);
SHA256ROUND(e, f, g, h, a, b, c, d, 52, w4);
w5 = add4(SIGMA1_256(w3), w14, SIGMA0_256(w6), w5);
SHA256ROUND(d, e, f, g, h, a, b, c, 53, w5);
w6 = add4(SIGMA1_256(w4), w15, SIGMA0_256(w7), w6);
SHA256ROUND(c, d, e, f, g, h, a, b, 54, w6);
w7 = add4(SIGMA1_256(w5), w0, SIGMA0_256(w8), w7);
SHA256ROUND(b, c, d, e, f, g, h, a, 55, w7);
w8 = add4(SIGMA1_256(w6), w1, SIGMA0_256(w9), w8);
SHA256ROUND(a, b, c, d, e, f, g, h, 56, w8);
w9 = add4(SIGMA1_256(w7), w2, SIGMA0_256(w10), w9);
SHA256ROUND(h, a, b, c, d, e, f, g, 57, w9);
w10 = add4(SIGMA1_256(w8), w3, SIGMA0_256(w11), w10);
SHA256ROUND(g, h, a, b, c, d, e, f, 58, w10);
w11 = add4(SIGMA1_256(w9), w4, SIGMA0_256(w12), w11);
SHA256ROUND(f, g, h, a, b, c, d, e, 59, w11);
w12 = add4(SIGMA1_256(w10), w5, SIGMA0_256(w13), w12);
SHA256ROUND(e, f, g, h, a, b, c, d, 60, w12);
w13 = add4(SIGMA1_256(w11), w6, SIGMA0_256(w14), w13);
SHA256ROUND(d, e, f, g, h, a, b, c, 61, w13);
w14 = add4(SIGMA1_256(w12), w7, SIGMA0_256(w15), w14);
SHA256ROUND(c, d, e, f, g, h, a, b, 62, w14);
w15 = add4(SIGMA1_256(w13), w8, SIGMA0_256(w0), w15);
SHA256ROUND(b, c, d, e, f, g, h, a, 63, w15);
#define store_load(x, i, dest) \
T1 = (vector unsigned int)((hPre)[i],(hPre)[i],(hPre)[i],(hPre)[i]); \
dest = vec_add(T1, x);
store_load(a, 0, w0);
store_load(b, 1, w1);
store_load(c, 2, w2);
store_load(d, 3, w3);
store_load(e, 4, w4);
store_load(f, 5, w5);
store_load(g, 6, w6);
store_load(h, 7, w7);
/* end of first SHA256 round */
w8 = (vector unsigned int)(Pad[8],Pad[8],Pad[8],Pad[8]);
w9 = (vector unsigned int)(Pad[9],Pad[9],Pad[9],Pad[9]);
w10 = (vector unsigned int)(Pad[10],Pad[10],Pad[10],Pad[10]);
w11 = (vector unsigned int)(Pad[11],Pad[11],Pad[11],Pad[11]);
w12 = (vector unsigned int)(Pad[12],Pad[12],Pad[12],Pad[12]);
w13 = (vector unsigned int)(Pad[13],Pad[13],Pad[13],Pad[13]);
w14 = (vector unsigned int)(Pad[14],Pad[14],Pad[14],Pad[14]);
w15 = (vector unsigned int)(Pad[15],Pad[15],Pad[15],Pad[15]);
a = (vector unsigned int)(hInit[0],hInit[0],hInit[0],hInit[0]);
b = (vector unsigned int)(hInit[1],hInit[1],hInit[1],hInit[1]);
c = (vector unsigned int)(hInit[2],hInit[2],hInit[2],hInit[2]);
d = (vector unsigned int)(hInit[3],hInit[3],hInit[3],hInit[3]);
e = (vector unsigned int)(hInit[4],hInit[4],hInit[4],hInit[4]);
f = (vector unsigned int)(hInit[5],hInit[5],hInit[5],hInit[5]);
g = (vector unsigned int)(hInit[6],hInit[6],hInit[6],hInit[6]);
h = (vector unsigned int)(hInit[7],hInit[7],hInit[7],hInit[7]);
SHA256ROUND(a, b, c, d, e, f, g, h, 0, w0);
SHA256ROUND(h, a, b, c, d, e, f, g, 1, w1);
SHA256ROUND(g, h, a, b, c, d, e, f, 2, w2);
SHA256ROUND(f, g, h, a, b, c, d, e, 3, w3);
SHA256ROUND(e, f, g, h, a, b, c, d, 4, w4);
SHA256ROUND(d, e, f, g, h, a, b, c, 5, w5);
SHA256ROUND(c, d, e, f, g, h, a, b, 6, w6);
SHA256ROUND(b, c, d, e, f, g, h, a, 7, w7);
SHA256ROUND(a, b, c, d, e, f, g, h, 8, w8);
SHA256ROUND(h, a, b, c, d, e, f, g, 9, w9);
SHA256ROUND(g, h, a, b, c, d, e, f, 10, w10);
SHA256ROUND(f, g, h, a, b, c, d, e, 11, w11);
SHA256ROUND(e, f, g, h, a, b, c, d, 12, w12);
SHA256ROUND(d, e, f, g, h, a, b, c, 13, w13);
SHA256ROUND(c, d, e, f, g, h, a, b, 14, w14);
SHA256ROUND(b, c, d, e, f, g, h, a, 15, w15);
w0 = add4(SIGMA1_256(w14), w9, SIGMA0_256(w1), w0);
SHA256ROUND(a, b, c, d, e, f, g, h, 16, w0);
w1 = add4(SIGMA1_256(w15), w10, SIGMA0_256(w2), w1);
SHA256ROUND(h, a, b, c, d, e, f, g, 17, w1);
w2 = add4(SIGMA1_256(w0), w11, SIGMA0_256(w3), w2);
SHA256ROUND(g, h, a, b, c, d, e, f, 18, w2);
w3 = add4(SIGMA1_256(w1), w12, SIGMA0_256(w4), w3);
SHA256ROUND(f, g, h, a, b, c, d, e, 19, w3);
w4 = add4(SIGMA1_256(w2), w13, SIGMA0_256(w5), w4);
SHA256ROUND(e, f, g, h, a, b, c, d, 20, w4);
w5 = add4(SIGMA1_256(w3), w14, SIGMA0_256(w6), w5);
SHA256ROUND(d, e, f, g, h, a, b, c, 21, w5);
w6 = add4(SIGMA1_256(w4), w15, SIGMA0_256(w7), w6);
SHA256ROUND(c, d, e, f, g, h, a, b, 22, w6);
w7 = add4(SIGMA1_256(w5), w0, SIGMA0_256(w8), w7);
SHA256ROUND(b, c, d, e, f, g, h, a, 23, w7);
w8 = add4(SIGMA1_256(w6), w1, SIGMA0_256(w9), w8);
SHA256ROUND(a, b, c, d, e, f, g, h, 24, w8);
w9 = add4(SIGMA1_256(w7), w2, SIGMA0_256(w10), w9);
SHA256ROUND(h, a, b, c, d, e, f, g, 25, w9);
w10 = add4(SIGMA1_256(w8), w3, SIGMA0_256(w11), w10);
SHA256ROUND(g, h, a, b, c, d, e, f, 26, w10);
w11 = add4(SIGMA1_256(w9), w4, SIGMA0_256(w12), w11);
SHA256ROUND(f, g, h, a, b, c, d, e, 27, w11);
w12 = add4(SIGMA1_256(w10), w5, SIGMA0_256(w13), w12);
SHA256ROUND(e, f, g, h, a, b, c, d, 28, w12);
w13 = add4(SIGMA1_256(w11), w6, SIGMA0_256(w14), w13);
SHA256ROUND(d, e, f, g, h, a, b, c, 29, w13);
w14 = add4(SIGMA1_256(w12), w7, SIGMA0_256(w15), w14);
SHA256ROUND(c, d, e, f, g, h, a, b, 30, w14);
w15 = add4(SIGMA1_256(w13), w8, SIGMA0_256(w0), w15);
SHA256ROUND(b, c, d, e, f, g, h, a, 31, w15);
w0 = add4(SIGMA1_256(w14), w9, SIGMA0_256(w1), w0);
SHA256ROUND(a, b, c, d, e, f, g, h, 32, w0);
w1 = add4(SIGMA1_256(w15), w10, SIGMA0_256(w2), w1);
SHA256ROUND(h, a, b, c, d, e, f, g, 33, w1);
w2 = add4(SIGMA1_256(w0), w11, SIGMA0_256(w3), w2);
SHA256ROUND(g, h, a, b, c, d, e, f, 34, w2);
w3 = add4(SIGMA1_256(w1), w12, SIGMA0_256(w4), w3);
SHA256ROUND(f, g, h, a, b, c, d, e, 35, w3);
w4 = add4(SIGMA1_256(w2), w13, SIGMA0_256(w5), w4);
SHA256ROUND(e, f, g, h, a, b, c, d, 36, w4);
w5 = add4(SIGMA1_256(w3), w14, SIGMA0_256(w6), w5);
SHA256ROUND(d, e, f, g, h, a, b, c, 37, w5);
w6 = add4(SIGMA1_256(w4), w15, SIGMA0_256(w7), w6);
SHA256ROUND(c, d, e, f, g, h, a, b, 38, w6);
w7 = add4(SIGMA1_256(w5), w0, SIGMA0_256(w8), w7);
SHA256ROUND(b, c, d, e, f, g, h, a, 39, w7);
w8 = add4(SIGMA1_256(w6), w1, SIGMA0_256(w9), w8);
SHA256ROUND(a, b, c, d, e, f, g, h, 40, w8);
w9 = add4(SIGMA1_256(w7), w2, SIGMA0_256(w10), w9);
SHA256ROUND(h, a, b, c, d, e, f, g, 41, w9);
w10 = add4(SIGMA1_256(w8), w3, SIGMA0_256(w11), w10);
SHA256ROUND(g, h, a, b, c, d, e, f, 42, w10);
w11 = add4(SIGMA1_256(w9), w4, SIGMA0_256(w12), w11);
SHA256ROUND(f, g, h, a, b, c, d, e, 43, w11);
w12 = add4(SIGMA1_256(w10), w5, SIGMA0_256(w13), w12);
SHA256ROUND(e, f, g, h, a, b, c, d, 44, w12);
w13 = add4(SIGMA1_256(w11), w6, SIGMA0_256(w14), w13);
SHA256ROUND(d, e, f, g, h, a, b, c, 45, w13);
w14 = add4(SIGMA1_256(w12), w7, SIGMA0_256(w15), w14);
SHA256ROUND(c, d, e, f, g, h, a, b, 46, w14);
w15 = add4(SIGMA1_256(w13), w8, SIGMA0_256(w0), w15);
SHA256ROUND(b, c, d, e, f, g, h, a, 47, w15);
w0 = add4(SIGMA1_256(w14), w9, SIGMA0_256(w1), w0);
SHA256ROUND(a, b, c, d, e, f, g, h, 48, w0);
w1 = add4(SIGMA1_256(w15), w10, SIGMA0_256(w2), w1);
SHA256ROUND(h, a, b, c, d, e, f, g, 49, w1);
w2 = add4(SIGMA1_256(w0), w11, SIGMA0_256(w3), w2);
SHA256ROUND(g, h, a, b, c, d, e, f, 50, w2);
w3 = add4(SIGMA1_256(w1), w12, SIGMA0_256(w4), w3);
SHA256ROUND(f, g, h, a, b, c, d, e, 51, w3);
w4 = add4(SIGMA1_256(w2), w13, SIGMA0_256(w5), w4);
SHA256ROUND(e, f, g, h, a, b, c, d, 52, w4);
w5 = add4(SIGMA1_256(w3), w14, SIGMA0_256(w6), w5);
SHA256ROUND(d, e, f, g, h, a, b, c, 53, w5);
w6 = add4(SIGMA1_256(w4), w15, SIGMA0_256(w7), w6);
SHA256ROUND(c, d, e, f, g, h, a, b, 54, w6);
w7 = add4(SIGMA1_256(w5), w0, SIGMA0_256(w8), w7);
SHA256ROUND(b, c, d, e, f, g, h, a, 55, w7);
w8 = add4(SIGMA1_256(w6), w1, SIGMA0_256(w9), w8);
SHA256ROUND(a, b, c, d, e, f, g, h, 56, w8);
w9 = add4(SIGMA1_256(w7), w2, SIGMA0_256(w10), w9);
SHA256ROUND(h, a, b, c, d, e, f, g, 57, w9);
w10 = add4(SIGMA1_256(w8), w3, SIGMA0_256(w11), w10);
SHA256ROUND(g, h, a, b, c, d, e, f, 58, w10);
w11 = add4(SIGMA1_256(w9), w4, SIGMA0_256(w12), w11);
SHA256ROUND(f, g, h, a, b, c, d, e, 59, w11);
w12 = add4(SIGMA1_256(w10), w5, SIGMA0_256(w13), w12);
SHA256ROUND(e, f, g, h, a, b, c, d, 60, w12);
/* Skip last 3-rounds; not necessary for H==0 */
/*#if 0
w13 = add4(SIGMA1_256(w11), w6, SIGMA0_256(w14), w13);
SHA256ROUND(d, e, f, g, h, a, b, c, 61, w13);
w14 = add4(SIGMA1_256(w12), w7, SIGMA0_256(w15), w14);
SHA256ROUND(c, d, e, f, g, h, a, b, 62, w14);
w15 = add4(SIGMA1_256(w13), w8, SIGMA0_256(w0), w15);
SHA256ROUND(b, c, d, e, f, g, h, a, 63, w15);
#endif*/
/* store resulsts directly in thash */
#define store_2(x,i) \
w0 = (vector unsigned int)(hInit[i],hInit[i],hInit[i],hInit[i]); \
vec_st(vec_add(w0, x), 0 ,&thash[i][k]);
store_2(a, 0);
store_2(b, 1);
store_2(c, 2);
store_2(d, 3);
store_2(e, 4);
store_2(f, 5);
store_2(g, 6);
store_2(h, 7);
vec_st(nonce, 0 ,&thash[8][k]);
/* writing the results into the array is time intensive */
/* -> try if it´s faster to compare the results with the target inside this function */
}
}
int main(int argc, char **argv)
{
char id[UUID_STR_LEN + 1];
int cf_index, ret, type;
Octstr *os, *store_type, *store_location, *status;
Msg *msg;
CfgGroup *grp;
conf_file = NULL;
gwlib_init();
//This can be overwritten with the -v flag at runtime
log_set_output_level(DEFAULT_LOG_LEVEL);
cf_index = get_and_set_debugs(argc, argv, check_args);
if (argv[cf_index] == NULL) {
print_usage(argv[0]);
goto error;
}
if (conf_file == NULL)
conf_file = octstr_create("kannel.conf");
cfg = cfg_create(conf_file);
if (cfg_read(cfg) == -1)
panic(0, "Couldn't read configuration from `%s'.", octstr_get_cstr(conf_file));
info(0, "1");
grp = cfg_get_single_group(cfg, octstr_imm("core"));
if (grp == NULL) {
printf("FATAL: Could not load Kannel's core group. Exiting.\n");
return 2;
}
store_location = cfg_get(grp, octstr_imm("store-location"));
store_type = cfg_get(grp, octstr_imm("store-type"));
store_init(store_type, store_location, -1, msg_pack, msg_unpack_wrapper);
switch (command) {
case COMMAND_LIST:
printf("Listing records %d -> %d\n", list_from+1, list_limit);
print_header();
store_load(print_msg);
if (counter == 0) {
printf("|%60s%14s%60s|\n", "", "Store is Empty", "");
}
print_sep();
break;
case COMMAND_DELETE:
store_load(msg_count);
msg = msg_create(ack);
msg->ack.nack = ack_failed;
msg->ack.time = time(NULL);
uuid_parse(octstr_get_cstr(param_1), msg->ack.id);
ret = store_save(msg);
if (ret == 0) {
printf("Deleted message %s\n", octstr_get_cstr(param_1));
counter--;
} else {
printf("Could not delete message %s\n", octstr_get_cstr(param_1));
}
msg_destroy(msg);
break;
case COMMAND_EXPORT:
counter = 0;
type = 0;
list = gwlist_create();
store_load(msg_push);
printf("Exporting %ld messages...\n", gwlist_len(list));
if ((octstr_compare(param_1, octstr_imm("file")) == 0) ||
(octstr_compare(param_1, octstr_imm("spool")) == 0)) {
store_shutdown();
store_init(param_1, param_2, -1, msg_pack, msg_unpack_wrapper);
store_load(msg_count);
while ((os = gwlist_extract_first(list)) != NULL) {
msg = msg_unpack_wrapper(os);
if (msg != NULL) {
ret = store_save(msg);
if (ret == 0) {
counter++;
} else {
printf("Error saving message\n");
}
} else {
printf("Error extracting message\n");
}
msg_destroy(msg);
}
status = NULL;
} else if (octstr_compare(param_1, octstr_imm("text")) == 0) {
status = store_status(BBSTATUS_TEXT);
} else if (octstr_compare(param_1, octstr_imm("html")) == 0) {
status = store_status(BBSTATUS_HTML);
} else if (octstr_compare(param_1, octstr_imm("xml")) == 0) {
status = store_status(BBSTATUS_XML);
} else {
status = NULL;
}
if (status != NULL) {
file = fopen(octstr_get_cstr(param_2), "w");
if (file == NULL) {
error(errno, "Failed to open '%s' for writing, cannot create output file",
octstr_get_cstr(param_2));
return -1;
}
octstr_print(file, status);
fflush(file);
if (file != NULL)
fclose(file);
//printf("%s", octstr_get_cstr(status));
}
gwlist_destroy(list, octstr_destroy_item);
break;
default:
break;
}
octstr_destroy(store_type);
octstr_destroy(store_location);
cfg_destroy(cfg);
store_shutdown();
error:
gwlib_shutdown();
return 1;
}