/*
* The current keyblock will be deleted.
*/
int
keydb_delete_keyblock (KEYDB_HANDLE hd)
{
int rc = -1;
if (!hd)
return G10ERR_INV_ARG;
if ( hd->found < 0 || hd->found >= hd->used)
return -1; /* nothing found */
if( opt.dry_run )
return 0;
rc = lock_all (hd);
if (rc)
return rc;
switch (hd->active[hd->found].type) {
case KEYDB_RESOURCE_TYPE_NONE:
rc = G10ERR_GENERAL; /* oops */
break;
case KEYDB_RESOURCE_TYPE_KEYRING:
rc = keyring_delete_keyblock (hd->active[hd->found].u.kr);
break;
}
unlock_all (hd);
return rc;
}
/* Update the current keyblock with KB. */
int
keydb_update_cert (KEYDB_HANDLE hd, ksba_cert_t cert)
{
int rc = 0;
unsigned char digest[20];
if (!hd)
return gpg_error (GPG_ERR_INV_VALUE);
if ( hd->found < 0 || hd->found >= hd->used)
return -1; /* nothing found */
if (opt.dry_run)
return 0;
rc = lock_all (hd);
if (rc)
return rc;
gpgsm_get_fingerprint (cert, GCRY_MD_SHA1, digest, NULL); /* kludge*/
switch (hd->active[hd->found].type)
{
case KEYDB_RESOURCE_TYPE_NONE:
rc = gpg_error (GPG_ERR_GENERAL); /* oops */
break;
case KEYDB_RESOURCE_TYPE_KEYBOX:
rc = keybox_update_cert (hd->active[hd->found].u.kr, cert, digest);
break;
}
unlock_all (hd);
return rc;
}
/* free all resources, close all threads */
int bsreader_close(void)
{
int ret = 0;
lock_all();
//TODO, possible release
if (!G_ready) {
printf("has not opened, cannot close\n");
return -1;
}
if (cancel_working_thread() < 0) {
perror("pthread_cancel bsreader main");
return -1;
} else {
DEBUG_PRINT("main working thread canceled \n");
}
fifo_close(myFIFO[0]);
fifo_close(myFIFO[1]);
fifo_close(myFIFO[2]);
fifo_close(myFIFO[3]);
if (G_bsreader_init_data.cavlc_possible) {
destroy_cavlc();
}
G_ready = 0;
unlock_all();
pthread_mutex_destroy(&G_all_mutex);
return ret;
}
/*
* Insert a new KB into one of the resources.
*/
int
keydb_insert_keyblock (KEYDB_HANDLE hd, KBNODE kb)
{
int rc = -1;
int idx;
if (!hd)
return G10ERR_INV_ARG;
if( opt.dry_run )
return 0;
if ( hd->found >= 0 && hd->found < hd->used)
idx = hd->found;
else if ( hd->current >= 0 && hd->current < hd->used)
idx = hd->current;
else
return G10ERR_GENERAL;
rc = lock_all (hd);
if (rc)
return rc;
switch (hd->active[idx].type) {
case KEYDB_RESOURCE_TYPE_NONE:
rc = G10ERR_GENERAL; /* oops */
break;
case KEYDB_RESOURCE_TYPE_KEYRING:
rc = keyring_insert_keyblock (hd->active[idx].u.kr, kb);
break;
}
unlock_all (hd);
return rc;
}
/*
* Insert a new KB into one of the resources.
*/
gpg_error_t
keydb_insert_keyblock (KEYDB_HANDLE hd, kbnode_t kb)
{
gpg_error_t err;
int idx;
if (!hd)
return gpg_error (GPG_ERR_INV_ARG);
keyblock_cache_clear ();
if (opt.dry_run)
return 0;
if (hd->found >= 0 && hd->found < hd->used)
idx = hd->found;
else if (hd->current >= 0 && hd->current < hd->used)
idx = hd->current;
else
return gpg_error (GPG_ERR_GENERAL);
err = lock_all (hd);
if (err)
return err;
switch (hd->active[idx].type)
{
case KEYDB_RESOURCE_TYPE_NONE:
err = gpg_error (GPG_ERR_GENERAL); /* oops */
break;
case KEYDB_RESOURCE_TYPE_KEYRING:
err = keyring_insert_keyblock (hd->active[idx].u.kr, kb);
break;
case KEYDB_RESOURCE_TYPE_KEYBOX:
{ /* We need to turn our kbnode_t list of packets into a proper
keyblock first. This is required by the OpenPGP key parser
included in the keybox code. Eventually we can change this
kludge to have the caller pass the image. */
iobuf_t iobuf;
u32 *sigstatus;
err = build_keyblock_image (kb, &iobuf, &sigstatus);
if (!err)
{
err = keybox_insert_keyblock (hd->active[idx].u.kb,
iobuf_get_temp_buffer (iobuf),
iobuf_get_temp_length (iobuf),
sigstatus);
xfree (sigstatus);
iobuf_close (iobuf);
}
}
break;
}
unlock_all (hd);
return err;
}
/* If the keyring has not yet been locked, lock it now. This
operation is required before any update operation; it is optional
for an insert operation. The lock is released with
keydb_released. */
gpg_error_t
keydb_lock (KEYDB_HANDLE hd)
{
if (!hd)
return gpg_error (GPG_ERR_INV_HANDLE);
if (hd->locked)
return 0; /* Already locked. */
return lock_all (hd);
}
/* allocate memory and do data initialization, threads initialization, also call reset write/read pointers */
int bsreader_open(void)
{
int ret = 0;
u32 max_entry_num;
lock_all();
if (G_ready) {
printf("already opened\n");
return -1;
}
//init iav and test iav state, it's expected iav should not be in encoding, before open bsreader
if (init_iav() < 0) {
ret = -3;
goto error_catch;
}
max_entry_num = G_bsreader_init_data.max_buffered_frame_num;
myFIFO[0] = fifo_create(G_bsreader_init_data.ring_buf_size[0], sizeof(bs_info_t), max_entry_num);
myFIFO[1] = fifo_create(G_bsreader_init_data.ring_buf_size[1], sizeof(bs_info_t), max_entry_num);
myFIFO[2] = fifo_create(G_bsreader_init_data.ring_buf_size[2], sizeof(bs_info_t), max_entry_num);
myFIFO[3] = fifo_create(G_bsreader_init_data.ring_buf_size[3], sizeof(bs_info_t), max_entry_num);
//init cavlc
if (G_bsreader_init_data.cavlc_possible) {
if (init_cavlc() < 0) {
printf("init cavlc in bsreader error \n");
ret = -2;
goto error_catch;
}
}
//create thread after all other initialization is done
if (create_working_thread() < 0) {
printf("create working thread error \n");
ret = -1;
goto error_catch;
}
G_ready = 1;
unlock_all();
return 0;
error_catch:
cancel_working_thread();
if (G_bsreader_init_data.cavlc_possible) {
destroy_cavlc();
}
unlock_all();
printf("bsreader opened.\n");
return ret;
}
HRESULT clear()
{
HRESULT result = lock_all();
if (DS_OK != result)
return result;
assert(m_bytes1);
assert(!m_bytes2);
assert(m_size == m_locked1);
assert(0U == m_locked2);
memset(m_bytes1, 0, m_locked1);
unlock();
return DS_OK;
}
/*
* Update the current keyblock with the keyblock KB
*/
gpg_error_t
keydb_update_keyblock (KEYDB_HANDLE hd, kbnode_t kb)
{
gpg_error_t rc;
if (!hd)
return gpg_error (GPG_ERR_INV_ARG);
keyblock_cache_clear ();
if (hd->found < 0 || hd->found >= hd->used)
return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
if (opt.dry_run)
return 0;
rc = lock_all (hd);
if (rc)
return rc;
switch (hd->active[hd->found].type)
{
case KEYDB_RESOURCE_TYPE_NONE:
rc = gpg_error (GPG_ERR_GENERAL); /* oops */
break;
case KEYDB_RESOURCE_TYPE_KEYRING:
rc = keyring_update_keyblock (hd->active[hd->found].u.kr, kb);
break;
/* case KEYDB_RESOURCE_TYPE_KEYRING: */
/* rc = build_keyblock (kb, &image, &imagelen); */
/* if (!rc) */
/* rc = keybox_update_keyblock (hd->active[hd->found].u.kb, */
/* image, imagelen); */
/* break; */
}
unlock_all (hd);
return rc;
}
/*
* Delete the current keyblock.
*/
gpg_error_t
keydb_delete_keyblock (KEYDB_HANDLE hd)
{
gpg_error_t rc;
if (!hd)
return gpg_error (GPG_ERR_INV_ARG);
keyblock_cache_clear ();
if (hd->found < 0 || hd->found >= hd->used)
return gpg_error (GPG_ERR_VALUE_NOT_FOUND);
if (opt.dry_run)
return 0;
rc = lock_all (hd);
if (rc)
return rc;
switch (hd->active[hd->found].type)
{
case KEYDB_RESOURCE_TYPE_NONE:
rc = gpg_error (GPG_ERR_GENERAL);
break;
case KEYDB_RESOURCE_TYPE_KEYRING:
rc = keyring_delete_keyblock (hd->active[hd->found].u.kr);
break;
case KEYDB_RESOURCE_TYPE_KEYBOX:
rc = keybox_delete (hd->active[hd->found].u.kb);
break;
}
unlock_all (hd);
return rc;
}
/* Store the certificate in the key DB but make sure that it does not
already exists. We do this simply by comparing the fingerprint.
If EXISTED is not NULL it will be set to true if the certificate
was already in the DB. */
int
keydb_store_cert (ksba_cert_t cert, int ephemeral, int *existed)
{
KEYDB_HANDLE kh;
int rc;
unsigned char fpr[20];
if (existed)
*existed = 0;
if (!gpgsm_get_fingerprint (cert, 0, fpr, NULL))
{
log_error (_("failed to get the fingerprint\n"));
return gpg_error (GPG_ERR_GENERAL);
}
kh = keydb_new (0);
if (!kh)
{
log_error (_("failed to allocate keyDB handle\n"));
return gpg_error (GPG_ERR_ENOMEM);;
}
/* Set the ephemeral flag so that the search looks at all
records. */
keydb_set_ephemeral (kh, 1);
rc = lock_all (kh);
if (rc)
return rc;
rc = keydb_search_fpr (kh, fpr);
if (rc != -1)
{
keydb_release (kh);
if (!rc)
{
if (existed)
*existed = 1;
if (!ephemeral)
{
/* Remove ephemeral flags from existing certificate to "store"
it permanently. */
rc = keydb_set_cert_flags (cert, 1, KEYBOX_FLAG_BLOB, 0,
KEYBOX_FLAG_BLOB_EPHEMERAL, 0);
if (rc)
{
log_error ("clearing ephemeral flag failed: %s\n",
gpg_strerror (rc));
return rc;
}
}
return 0; /* okay */
}
log_error (_("problem looking for existing certificate: %s\n"),
gpg_strerror (rc));
return rc;
}
/* Reset the ephemeral flag if not requested. */
if (!ephemeral)
keydb_set_ephemeral (kh, 0);
rc = keydb_locate_writable (kh, 0);
if (rc)
{
log_error (_("error finding writable keyDB: %s\n"), gpg_strerror (rc));
keydb_release (kh);
return rc;
}
rc = keydb_insert_cert (kh, cert);
if (rc)
{
log_error (_("error storing certificate: %s\n"), gpg_strerror (rc));
keydb_release (kh);
return rc;
}
keydb_release (kh);
return 0;
}
int main(int argc, char *argv[])
{
unsigned long srv_name = nam2num("SRV");
RT_TASK *srv;
pid_t pid, my_pid ;
int err, i, count, msglen, *zpt ;
RTIME period, delay;
char *opt;
QBLK *q;
hrt = 1;
crashkern = 0;
for( i=1 ; i < argc ; i++ ) {
opt = argv[i];
switch((*opt<<8) + *(opt+1)) {
case OPT_MINUS('k'):
crashkern++;
break;
case OPT_MINUS('f'):
crashfunc++;
break;
case OPT_MINUS('q'):
query++;
break;
case OPT_MINUS('s'):
hrt--;
break;
}
}
if(query) {
printf("STOMP OVER KERNEL MEMORY FROM KERNEL (!=0) OR USER SPACE CODE (==0):");
scanf("%d", &crashkern);
printf("STOMP OVER KERNEL MEMORY FROM QBLK FUNCTION (!=0) OR NORMAL USER SPACE (==0):");
scanf("%d", &crashfunc);
printf("STOMP OVER KERNEL MEMORY FROM HARD REALTIME (!=0) OR SOFT REALTIME (==0):");
scanf("%d", &hrt);
}
init_linux_scheduler(SCHED_FIFO, 98);
err = lock_all(0,0);
if(err) {
printf("lock_all() failed\n");
exit(2);
}
printf("SRV in %s mode to write over kernel memory %sfrom %s space\n", hrt ? "HRT" : "POSIX", crashfunc ? "in qBlk ":"", crashkern ? "kernel" : "user");
if (!(srv = rt_task_init(srv_name, 0, 0, 0))) {
printf("CANNOT INIT SRV TASK\n");
exit(3);
}
rt_set_oneshot_mode();
period = nano2count(10000000);
start_rt_timer(period);
// printf("SRV starts\n");
if (hrt) rt_make_hard_real_time();
rt_task_make_periodic(srv, rt_get_time() + period, period);
my_pid = rt_Alias_attach("");
if(!my_pid) {
rtai_print_to_screen("Cannot attach name\n");
goto Exit;
}
rt_InitTickQueue();
rt_qDynAlloc(32);
rt_sleep(nano2count(1000000000));
i = count = 0 ;
zpt = (int *)0xc43d0128; // kernel's address space
while(++count) {
memset( msg, 0, sizeof(msg));
pid = rt_Creceive( 0, msg, sizeof(msg), &msglen, period);
if(pid) {
rtai_print_to_screen("SRV received msg [%s] %d bytes from pid %04X\n", msg, msglen, pid);
memcpy( rep, msg, sizeof(rep));
if(rt_Reply(pid, rep, sizeof(rep)))
rtai_print_to_screen("SRV rt_Reply() failed\n");
}
rtai_print_to_screen("SRV Loop %d\n", count);
if(count == 10 && !crashfunc) {
if (crashkern) {
rt_stomp();
} else {
// __asm__("cli; hlt"); // Privilige check!
*zpt = -1; // Bad pointer
}
} else if(count == 10) {
q = rt_qDynInit( 0, YetAnotherOne, 0, 0);
delay = nano2count(100000000);
rt_qBlkWait(q, delay);
rt_qLoop();
}
if(count == 20) break;
}
if(rt_Name_detach(my_pid))
rtai_print_to_screen("SRV cannot detach name\n");
rt_sleep(nano2count(1000000000));
Exit:
if (hrt) rt_make_soft_real_time();
if(rt_task_delete(srv))
rtai_print_to_screen("SRV cannot delete task\n");
stop_rt_timer();
exit(0);
}
int main(int argc, char* argv[])
{
unsigned long srv_name = nam2num("SRV");
RT_TASK *srv;
pid_t pid, my_pid, proxy ;
int err,/* i,*/ count, msglen ;
RTIME period;
char *pt;
init_linux_scheduler(SCHED_FIFO, 98);
err = lock_all(0,0);
if(err) {
printf("lock_all() fails\n");
exit(-1);
}
if (!(srv = rt_task_init(srv_name, 0, 0, 0))) {
printf("CANNOT INIT SRV TASK\n");
exit(-1);
}
my_pid = rt_Alias_attach("");
if(!my_pid) {
rtai_print_to_screen("Cannot attach name SRV\n");
exit(-1);
}
period = nano2count(1000000);
rt_set_oneshot_mode();
start_rt_timer(period);
printf("SRV starts (%p)\n", srv);
rt_make_hard_real_time();
rt_task_make_periodic(srv, rt_get_time(), period);
proxy = rt_Proxy_attach( 0, "More beer please", 17, -1);
if(proxy <= 0 ) {
rtai_print_to_screen("Failed to attach proxy\n");
exit(-1);
}
pid = rt_Receive( 0, 0, 0, &msglen);
if(pid) {
// handshake to give the proxy to CLT
rtai_print_to_screen("rt_Reply the proxy %04X msglen = %d\n", proxy, msglen);
rt_Reply( pid, &proxy, sizeof(proxy));
}
rt_sleep(nano2count(1000000000));
count = 8 ;
while(count--) {
memset( msg, 0, sizeof(msg));
pid = rt_Receive( 0, msg, sizeof(msg), &msglen);
if(pid == proxy) {
rtai_print_to_screen("SRV receives the PROXY event [%s]\n", msg);
continue;
} else if( pid <= 0) {
rtai_print_to_screen("SRV rt_Receive() failed\n");
// goto Exit;
continue;
}
rtai_print_to_screen("SRV received msg [%s] %d bytes from pid %04X\n", msg, msglen, pid);
memcpy( rep, msg, sizeof(rep));
pt = (char *) rep;
while(*pt) *pt++ = toupper(*pt);
if(rt_Reply(pid, rep, sizeof(rep)))
rtai_print_to_screen("SRV rt_Reply() failed\n");
}
if(rt_Proxy_detach(proxy))
rtai_print_to_screen("SRV cannot detach proxy\n");
if(rt_Name_detach(my_pid))
rtai_print_to_screen("SRV cannot detach name\n");
//Exit:
rt_make_soft_real_time();
rt_sleep(nano2count(1000000000));
if(rt_task_delete(srv))
rtai_print_to_screen("SRV cannot delete task\n");
return 0;
}
/* Store the certificate in the key DB but make sure that it does not
already exists. We do this simply by comparing the fingerprint.
If EXISTED is not NULL it will be set to true if the certificate
was already in the DB. */
int
keydb_store_cert (ksba_cert_t cert, int ephemeral, int *existed)
{
KEYDB_HANDLE kh;
int rc;
unsigned char fpr[20];
if (existed)
*existed = 0;
if (!gpgsm_get_fingerprint (cert, 0, fpr, NULL))
{
log_error (_("failed to get the fingerprint\n"));
return gpg_error (GPG_ERR_GENERAL);
}
kh = keydb_new (0);
if (!kh)
{
log_error (_("failed to allocate keyDB handle\n"));
return gpg_error (GPG_ERR_ENOMEM);;
}
if (ephemeral)
keydb_set_ephemeral (kh, 1);
rc = lock_all (kh);
if (rc)
return rc;
rc = keydb_search_fpr (kh, fpr);
if (rc != -1)
{
keydb_release (kh);
if (!rc)
{
if (existed)
*existed = 1;
return 0; /* okay */
}
log_error (_("problem looking for existing certificate: %s\n"),
gpg_strerror (rc));
return rc;
}
rc = keydb_locate_writable (kh, 0);
if (rc)
{
log_error (_("error finding writable keyDB: %s\n"), gpg_strerror (rc));
keydb_release (kh);
return rc;
}
rc = keydb_insert_cert (kh, cert);
if (rc)
{
log_error (_("error storing certificate: %s\n"), gpg_strerror (rc));
keydb_release (kh);
return rc;
}
keydb_release (kh);
return 0;
}
static void process_command(int *quit)
{
char inbuf[132];
int x = 0, y = 0;
if (!opt_cmd) {
fgets(inbuf, sizeof(inbuf), stdin);
sscanf(inbuf, "%s %d %d", cmd, &x, &y);
}
if (!strncmp(cmd, "EXIT", 4)) {
*quit = 1;
unlock_all();
return;
}
if (!strncmp(cmd, "CLOSE", 5)) {
*quit = 1;
openclose_ls = 1;
unlock_all();
return;
}
if (!strncmp(cmd, "kill", 4)) {
printf("process exiting\n");
exit(0);
}
if (!strncmp(cmd, "lock", 4) && strlen(cmd) == 4) {
lock(x, y);
return;
}
if (!strncmp(cmd, "unlock", 6) && strlen(cmd) == 6) {
unlock(x);
return;
}
if (!strncmp(cmd, "unlockf", 7) && strlen(cmd) == 7) {
unlockf(x);
return;
}
if (!strncmp(cmd, "cancel", 6) && strlen(cmd) == 6) {
cancel(x);
return;
}
if (!strncmp(cmd, "canceld", 7) && strlen(cmd) == 7) {
canceld(x, y);
return;
}
if (!strncmp(cmd, "lock_sync", 9) && strlen(cmd) == 9) {
lock_sync(x, y);
return;
}
if (!strncmp(cmd, "unlock_sync", 11) && strlen(cmd) == 11) {
unlock_sync(x);
return;
}
if (!strncmp(cmd, "lock-kill", 9) && strlen(cmd) == 9) {
lock(x, y);
printf("process exiting\n");
exit(0);
}
if (!strncmp(cmd, "unlock-kill", 11) && strlen(cmd) == 11) {
unlock(x);
printf("process exiting\n");
exit(0);
}
if (!strncmp(cmd, "lock-cancel", 11) && strlen(cmd) == 11) {
lock(x, y);
/* usleep(1000 * z); */
cancel(x);
return;
}
if (!strncmp(cmd, "lock-unlockf", 12) && strlen(cmd) == 12) {
lock(x, y);
/* usleep(1000 * z); */
unlockf(x);
return;
}
if (!strncmp(cmd, "ex", 2)) {
lock(x, LKM_EXMODE);
return;
}
if (!strncmp(cmd, "pr", 2)) {
lock(x, LKM_PRMODE);
return;
}
if (!strncmp(cmd, "hold", 4) && strlen(cmd) == 4) {
lock_all(LKM_PRMODE);
return;
}
if (!strncmp(cmd, "hold-kill", 9) && strlen(cmd) == 9) {
lock_all(LKM_PRMODE);
exit(0);
}
if (!strncmp(cmd, "release", 7) && strlen(cmd) == 7) {
unlock_all();
return;
}
if (!strncmp(cmd, "release-kill", 12) && strlen(cmd) == 12) {
unlock_all();
exit(0);
}
if (!strncmp(cmd, "dump", 4) && strlen(cmd) == 4) {
dump();
return;
}
if (!strncmp(cmd, "stress", 6) && strlen(cmd) == 6) {
if (iterations && !x)
x = iterations;
stress(x);
return;
}
if (!strncmp(cmd, "tstress", 7) && strlen(cmd) == 7) {
tstress(x);
return;
}
if (!strncmp(cmd, "dstress", 7) && strlen(cmd) == 7) {
dstress(x);
return;
}
if (!strncmp(cmd, "stress_delay", 12) && strlen(cmd) == 12) {
stress_delay = x;
return;
}
if (!strncmp(cmd, "stress_lock_only", 16) && strlen(cmd) == 16) {
stress_lock_only = !stress_lock_only;
printf("stress_lock_only is %s\n", stress_lock_only ? "on" : "off");
return;
}
if (!strncmp(cmd, "stress_stop", 11) && strlen(cmd) == 11) {
stress_stop = !stress_stop;
printf("stress_stop is %d\n", stress_stop);
return;
}
if (!strncmp(cmd, "ignore_bast", 11) && strlen(cmd) == 11) {
ignore_bast = !ignore_bast;
printf("ignore_bast is %s\n", ignore_bast ? "on" : "off");
return;
}
if (!strncmp(cmd, "our_xid", 7) && strlen(cmd) == 7) {
our_xid = x;
printf("our_xid is %llx\n", (unsigned long long)our_xid);
return;
}
if (!strncmp(cmd, "purge", 5) && strlen(cmd) == 5) {
purge(x, y);
return;
}
if (!strncmp(cmd, "purgetest", 9) && strlen(cmd) == 9) {
purgetest(x, y);
return;
}
if (!strncmp(cmd, "noqueue", 7)) {
noqueue = !noqueue;
printf("noqueue is %s\n", noqueue ? "on" : "off");
return;
}
if (!strncmp(cmd, "persistent", 10)) {
persistent = !persistent;
printf("persistent is %s\n", persistent ? "on" : "off");
return;
}
if (!strncmp(cmd, "minhold", 7)) {
minhold = x;
return;
}
if (!strncmp(cmd, "timeout", 7)) {
timeout = (uint64_t) 100 * x; /* dlm takes it in centiseconds */
printf("timeout is %d\n", x);
return;
}
if (!strncmp(cmd, "quiet", 5)) {
quiet = !quiet;
printf("quiet is %d\n", quiet);
return;
}
if (!strncmp(cmd, "verbose", 7)) {
verbose = !verbose;
printf("verbose is %d\n", verbose);
return;
}
if (!strncmp(cmd, "help", 4)) {
print_commands();
return;
}
if (!strncmp(cmd, "settings", 8)) {
print_settings();
return;
}
printf("unknown command %s\n", cmd);
}
