void ext_init(char *mode, struct db_main *db)
{
if (db!= NULL && db->format != NULL) {
ext_cipher_limit = maxlen = db->format->params.plaintext_length;
return;
}
else {
ext_cipher_limit = options.length;
}
if (!(ext_source = cfg_get_list(SECTION_EXT, mode))) {
#ifdef HAVE_MPI
if (mpi_id == 0)
#endif
fprintf(stderr, "Unknown external mode: %s\n", mode);
error();
}
if (c_compile(ext_getchar, ext_rewind, &ext_globals)) {
if (!ext_line) ext_line = ext_source->tail;
#ifdef HAVE_MPI
if (mpi_id == 0)
#endif
fprintf(stderr, "Compiler error in %s at line %d: %s\n",
ext_line->cfg_name, ext_line->number,
c_errors[c_errno]);
error();
}
ext_word[0] = 0;
c_execute(c_lookup("init"));
f_generate = c_lookup("generate");
f_filter = c_lookup("filter");
if ((ext_flags & EXT_REQ_GENERATE) && !f_generate) {
#ifdef HAVE_MPI
if (mpi_id == 0)
#endif
fprintf(stderr, "No generate() for external mode: %s\n", mode);
error();
}
if ((ext_flags & EXT_REQ_FILTER) && !f_filter) {
#ifdef HAVE_MPI
if (mpi_id == 0)
#endif
fprintf(stderr, "No filter() for external mode: %s\n", mode);
error();
}
if ((ext_flags & (EXT_USES_GENERATE | EXT_USES_FILTER)) ==
EXT_USES_FILTER && f_generate)
#ifdef HAVE_MPI
if (mpi_id == 0)
#endif
fprintf(stderr, "Warning: external mode defines generate(), "
"but is only used for filter()\n");
ext_mode = mode;
}
d_storeMMFKernel
d_storeMMFKernelAttach (
c_base base,
const c_char *name)
{
d_storeMMFKernel kernel = NULL;
if (name == NULL) {
OS_REPORT(OS_ERROR,
"d_storeMMFKernelAttach",0,
"Failed to lookup kernel, specified kernel name = <NULL>");
} else {
kernel = c_lookup(base,name);
if (kernel == NULL) {
OS_REPORT_1(OS_ERROR,
"d_storeMMFKernelAttach",0,
"Failed to lookup kernel '%s' in Database",
name);
} else if (c_checkType(kernel,"d_storeMMFKernel") != kernel) {
c_free(kernel);
kernel = NULL;
OS_REPORT_1(OS_ERROR,
"d_storeMMFKernelAttach",0,
"Object '%s' is apparently not of type 'd_storeMMFKernel'",
name);
}
}
return kernel;
}
void ext_init(char *mode)
{
if (!(ext_source = cfg_get_list(SECTION_EXT, mode))) {
fprintf(stderr, "Unknown external mode: %s\n", mode);
error();
}
if (c_compile(ext_getchar, ext_rewind, &ext_globals)) {
if (!ext_line) ext_line = ext_source->tail;
fprintf(stderr, "Compiler error in %s at line %d: %s\n",
cfg_name, ext_line->number,
c_errors[c_errno]);
error();
}
ext_word[0] = 0;
c_execute(c_lookup("init"));
f_generate = c_lookup("generate");
f_filter = c_lookup("filter");
ext_mode = mode;
}
int ext_has_function(char *mode, char *function)
{
if (!(ext_source = cfg_get_list(SECTION_EXT, mode))) {
fprintf(stderr, "Unknown external mode: %s\n", mode);
error();
}
if (c_compile(ext_getchar, ext_rewind, &ext_globals)) {
if (!ext_line) ext_line = ext_source->tail;
fprintf(stderr, "Compiler error in %s at line %d: %s\n",
ext_line->cfg_name, ext_line->number,
c_errors[c_errno]);
error();
}
return (c_lookup(function) != NULL);
}
v_kernel
v_kernelAttach(
c_base base,
const c_char *name)
{
v_kernel kernel = NULL;
os_uint32 attachCount;
if (name == NULL) {
OS_REPORT(OS_ERROR,
"v_kernelAttach",0,
"Failed to lookup kernel, specified kernel name = <NULL>");
} else {
kernel = c_lookup(base,name);
if (kernel == NULL) {
OS_REPORT_1(OS_ERROR,
"v_kernelAttach",0,
"Failed to lookup kernel '%s' in Database",
name);
} else if (c_checkType(kernel,"v_kernel") != kernel) {
c_free(kernel);
kernel = NULL;
OS_REPORT_1(OS_ERROR,
"v_kernelAttach",0,
"Object '%s' is apparently not of type 'v_kernel'",
name);
} else {
attachCount = pa_increment(&kernel->userCount);
if(attachCount == 1){
/* Result of the attach may NEVER be 1, as that would mean that an
* attach to an unreferenced kernel succeeded. If it happens, undo
* increment and free reference to returned kernel. */
pa_decrement(&kernel->userCount);
c_free(kernel);
kernel = NULL;
OS_REPORT_1(OS_ERROR,
"v_kernelAttach",0,
"Operation aborted: Object '%s' is apparently an "
"unreferenced kernel object.",
name);
}
}
}
return kernel;
}
static int restore_state(FILE *file)
{
int c;
unsigned char *internal;
c_int *external;
int count;
internal = (unsigned char *)int_word;
/* RYAN2 */
fprintf(stderr, "int_word = %s\n", int_word);
external = ext_word;
count = 0;
do {
if (fscanf(file, "%d\n", &c) != 1) return 1;
if (++count >= PLAINTEXT_BUFFER_SIZE) return 1;
} while ((*internal++ = *external++ = c));
c_execute(c_lookup("restore"));
return 0;
}
static int restore_state(FILE *file)
{
int c;
unsigned char *internal;
c_int *external;
int count;
internal = (unsigned char *)int_word;
external = ext_word;
count = 0;
do {
if (fscanf(file, "%d\n", &c) != 1) return 1;
if (++count >= PLAINTEXT_BUFFER_SIZE) return 1;
} while ((*internal++ = *external++ = c));
c_execute(c_lookup("restore"));
#ifdef HAVE_MPI
mpi_line = mpi_id + 1; // We just need the correct modulus
#endif
return 0;
}
static int restore_state(FILE *file)
{
int c;
unsigned char *internal;
c_int *external;
int count;
if (rec_version >= 4 && fscanf(file, "%u\n", &seq) != 1)
return 1;
internal = (unsigned char *)int_word;
external = ext_word;
count = 0;
do {
if (fscanf(file, "%d\n", &c) != 1) return 1;
if (++count >= PLAINTEXT_BUFFER_SIZE) return 1;
} while ((*internal++ = *external++ = c));
c_execute(c_lookup("restore"));
return 0;
}
void ext_init(char *mode, struct db_main *db)
{
if (db != NULL && db->format != NULL) {
/* This is second time we are called, just update max length */
ext_cipher_limit = maxlen =
db->format->params.plaintext_length - mask_add_len;
if (mask_num_qw > 1) {
ext_cipher_limit /= mask_num_qw;
maxlen /= mask_num_qw;
}
return;
} else
ext_cipher_limit = options.length;
ext_time = (int) time(NULL);
ext_maxlen = options.force_maxlength;
if (options.force_minlength > 0)
ext_minlen = options.force_minlength;
else
ext_minlen = 0;
if (!(ext_source = cfg_get_list(SECTION_EXT, mode))) {
if (john_main_process)
fprintf(stderr, "Unknown external mode: %s\n", mode);
error();
}
if (c_compile(ext_getchar, ext_rewind, &ext_globals)) {
if (!ext_line) ext_line = ext_source->tail;
if (john_main_process)
fprintf(stderr,
"Compiler error in %s at line %d: %s\n",
cfg_name, ext_line->number,
c_errors[c_errno]);
error();
}
ext_word[0] = 0;
c_execute(c_lookup("init"));
f_generate = c_lookup("generate");
f_filter = c_lookup("filter");
if ((ext_flags & EXT_REQ_GENERATE) && !f_generate) {
if (john_main_process)
fprintf(stderr,
"No generate() for external mode: %s\n", mode);
error();
}
if ((ext_flags & EXT_REQ_GENERATE) && !c_lookup("restore")) {
if (ext_flags & EXT_REQ_RESTORE) {
if (john_main_process)
fprintf(stderr,
"No restore() for external mode: %s\n",
mode);
error();
} else if (john_main_process)
fprintf(stderr,
"Warning: external mode '%s' can't be"
" resumed if aborted\n", mode);
}
if ((ext_flags & EXT_REQ_FILTER) && !f_filter) {
if (john_main_process)
fprintf(stderr,
"No filter() for external mode: %s\n", mode);
error();
}
if (john_main_process &&
(ext_flags & (EXT_USES_GENERATE | EXT_USES_FILTER)) ==
EXT_USES_FILTER && f_generate)
if (john_main_process)
fprintf(stderr, "Warning: external mode defines generate(), "
"but is only used for filter()\n");
ext_mode = mode;
}
void ext_init(char *mode, struct db_main *db)
{
if (!strncmp(mode, "gijohn", 5)) gijohnmodule = 1;
if (db) {
maxlen = db->format->params.plaintext_length;
return;
}
if (!gijohnmodule) {
if (!(ext_source = cfg_get_list(SECTION_EXT, mode))) {
#ifdef HAVE_MPI
if (mpi_id == 0)
#endif
fprintf(stderr, "Unknown external mode: %s\n", mode);
error();
}
if (c_compile(ext_getchar, ext_rewind, &ext_globals)) {
if (!ext_line) ext_line = ext_source->tail;
#ifdef HAVE_MPI
if (mpi_id == 0)
#endif
fprintf(stderr, "Compiler error in %s at line %d: %s\n",
ext_line->cfg_name, ext_line->number,
c_errors[c_errno]);
error();
}
}
ext_word[0] = 0;
c_execute(c_lookup("init"));
if (gijohnmodule)
{
sig_done();
getthenewpiece();
init_external(xmlxml.keymap.charset, strlen(xmlxml.keymap.charset),
xmlxml.keymap.firstword, xmlxml.keymap.lastword);
sig_init();
}
f_generate = c_lookup("generate");
f_filter = c_lookup("filter");
if (gijohnmodule)
{
ext_mode = mode;
return;
}
if ((ext_flags & EXT_REQ_GENERATE) && !f_generate) {
#ifdef HAVE_MPI
if (mpi_id == 0)
#endif
fprintf(stderr, "No generate() for external mode: %s\n", mode);
error();
}
if ((ext_flags & EXT_REQ_FILTER) && !f_filter) {
#ifdef HAVE_MPI
if (mpi_id == 0)
#endif
fprintf(stderr, "No filter() for external mode: %s\n", mode);
error();
}
if ((ext_flags & (EXT_USES_GENERATE | EXT_USES_FILTER)) ==
EXT_USES_FILTER && f_generate)
#ifdef HAVE_MPI
if (mpi_id == 0)
#endif
fprintf(stderr, "Warning: external mode defines generate(), "
"but is only used for filter()\n");
ext_mode = mode;
}
v_kernel
v_kernelNew(
c_base base,
const c_char *name,
v_kernelQos qos)
{
v_kernel kernel;
v_kernelStatistics kernelStatistics;
v_spliced sd;
kernel = c_lookup(base,name);
if (kernel != NULL) {
assert(C_TYPECHECK(kernel,v_kernel));
kernel->userCount++;
return kernel;
}
loadkernelModule(base);
kernel = (v_kernel)c_new(c_resolve(base,"kernelModule::v_kernel"));
if (!kernel) {
OS_REPORT(OS_ERROR,
"v_kernelNew",0,
"Failed to allocate kernel.");
return NULL;
}
v_objectKind(kernel) = K_KERNEL;
v_object(kernel)->kernel = (c_voidp)kernel;
kernel->handleServer = v_handleServerNew(base);
#define INITTYPE(k,t,l) k->type[l] = c_resolve(base,#t)
INITTYPE(kernel,kernelModule::v_kernel, K_KERNEL);
INITTYPE(kernel,kernelModule::v_participant, K_PARTICIPANT);
INITTYPE(kernel,kernelModule::v_waitset, K_WAITSET);
INITTYPE(kernel,kernelModule::v_condition, K_CONDITION);
INITTYPE(kernel,kernelModule::v_query, K_QUERY);
INITTYPE(kernel,kernelModule::v_dataReaderQuery, K_DATAREADERQUERY);
INITTYPE(kernel,kernelModule::v_dataViewQuery, K_DATAVIEWQUERY);
INITTYPE(kernel,kernelModule::v_dataView, K_DATAVIEW);
INITTYPE(kernel,kernelModule::v_dataViewSample, K_DATAVIEWSAMPLE);
INITTYPE(kernel,kernelModule::v_dataViewInstance, K_DATAVIEWINSTANCE);
INITTYPE(kernel,kernelModule::v_projection, K_PROJECTION);
INITTYPE(kernel,kernelModule::v_mapping, K_MAPPING);
INITTYPE(kernel,kernelModule::v_topic, K_TOPIC);
INITTYPE(kernel,kernelModule::v_message, K_MESSAGE);
INITTYPE(kernel,kernelModule::v_transaction, K_TRANSACTION);
INITTYPE(kernel,kernelModule::v_dataReaderInstance, K_DATAREADERINSTANCE);
INITTYPE(kernel,kernelModule::v_purgeListItem, K_PURGELISTITEM);
INITTYPE(kernel,kernelModule::v_groupPurgeItem, K_GROUPPURGEITEM);
INITTYPE(kernel,kernelModule::v_dataReaderSample, K_READERSAMPLE);
INITTYPE(kernel,kernelModule::v_publisher, K_PUBLISHER);
INITTYPE(kernel,kernelModule::v_subscriber, K_SUBSCRIBER);
INITTYPE(kernel,kernelModule::v_partition, K_DOMAIN);
INITTYPE(kernel,kernelModule::v_partitionInterest, K_DOMAININTEREST);
INITTYPE(kernel,kernelModule::v_partitionAdmin, K_DOMAINADMIN);
INITTYPE(kernel,kernelModule::v_reader, K_READER);
INITTYPE(kernel,kernelModule::v_writer, K_WRITER);
INITTYPE(kernel,kernelModule::v_writerGroup, K_WRITERGROUP);
INITTYPE(kernel,kernelModule::v_group, K_GROUP);
INITTYPE(kernel,kernelModule::v_groupInstance, K_GROUPINSTANCE);
INITTYPE(kernel,kernelModule::v_groupSample, K_GROUPSAMPLE);
INITTYPE(kernel,kernelModule::v_groupCacheItem, K_GROUPCACHEITEM);
INITTYPE(kernel,kernelModule::v_cache, K_CACHE);
INITTYPE(kernel,kernelModule::v_entry, K_ENTRY);
INITTYPE(kernel,kernelModule::v_dataReaderEntry, K_DATAREADERENTRY);
INITTYPE(kernel,kernelModule::v_groupAction, K_GROUPACTION);
INITTYPE(kernel,kernelModule::v_groupStream, K_GROUPSTREAM);
INITTYPE(kernel,kernelModule::v_groupQueue, K_GROUPQUEUE);
INITTYPE(kernel,kernelModule::v_groupQueueSample, K_GROUPQUEUESAMPLE);
INITTYPE(kernel,kernelModule::v_dataReader, K_DATAREADER);
INITTYPE(kernel,kernelModule::v_deliveryService, K_DELIVERYSERVICE);
INITTYPE(kernel,kernelModule::v_deliveryServiceEntry, K_DELIVERYSERVICEENTRY);
INITTYPE(kernel,kernelModule::v_index, K_INDEX);
INITTYPE(kernel,kernelModule::v_filter, K_FILTER);
INITTYPE(kernel,kernelModule::v_readerStatus, K_READERSTATUS);
INITTYPE(kernel,kernelModule::v_writerStatus, K_WRITERSTATUS);
INITTYPE(kernel,kernelModule::v_partitionStatus, K_DOMAINSTATUS);
INITTYPE(kernel,kernelModule::v_topicStatus, K_TOPICSTATUS);
INITTYPE(kernel,kernelModule::v_subscriberStatus, K_SUBSCRIBERSTATUS);
INITTYPE(kernel,kernelModule::v_status, K_PUBLISHERSTATUS);
INITTYPE(kernel,kernelModule::v_status, K_PARTICIPANTSTATUS);
INITTYPE(kernel,kernelModule::v_kernelStatus, K_KERNELSTATUS);
INITTYPE(kernel,kernelModule::v_readerStatistics, K_READERSTATISTICS);
INITTYPE(kernel,kernelModule::v_writerStatistics, K_WRITERSTATISTICS);
INITTYPE(kernel,kernelModule::v_queryStatistics, K_QUERYSTATISTICS);
INITTYPE(kernel,kernelModule::v_lease, K_LEASE);
INITTYPE(kernel,kernelModule::v_leaseAction, K_LEASEACTION);
INITTYPE(kernel,kernelModule::v_serviceManager, K_SERVICEMANAGER);
INITTYPE(kernel,kernelModule::v_service, K_SERVICE);
INITTYPE(kernel,kernelModule::v_serviceState, K_SERVICESTATE);
INITTYPE(kernel,kernelModule::v_networking, K_NETWORKING);
INITTYPE(kernel,kernelModule::v_durability, K_DURABILITY);
INITTYPE(kernel,kernelModule::v_cmsoap, K_CMSOAP);
INITTYPE(kernel,kernelModule::v_leaseManager, K_LEASEMANAGER);
INITTYPE(kernel,kernelModule::v_groupSet, K_GROUPSET);
INITTYPE(kernel,kernelModule::v_proxy, K_PROXY);
INITTYPE(kernel,kernelModule::v_waitsetEvent, K_WAITSETEVENT);
INITTYPE(kernel,kernelModule::v_waitsetEventHistoryDelete, K_WAITSETEVENTHISTORYDELETE);
INITTYPE(kernel,kernelModule::v_waitsetEventHistoryRequest, K_WAITSETEVENTHISTORYREQUEST);
INITTYPE(kernel,kernelModule::v_waitsetEventPersistentSnapshot, K_WAITSETEVENTPERSISTENTSNAPSHOT);
INITTYPE(kernel,kernelModule::v_writerSample, K_WRITERSAMPLE);
INITTYPE(kernel,kernelModule::v_writerInstance, K_WRITERINSTANCE);
INITTYPE(kernel,kernelModule::v_writerInstanceTemplate, K_WRITERINSTANCETEMPLATE);
INITTYPE(kernel,kernelModule::v_writerCacheItem, K_WRITERCACHEITEM);
/* Networking types */
INITTYPE(kernel,kernelModule::v_networkReader, K_NETWORKREADER);
INITTYPE(kernel,kernelModule::v_networkReaderEntry, K_NETWORKREADERENTRY);
INITTYPE(kernel,kernelModule::v_networkMessage, K_NETWORKMESSAGE);
INITTYPE(kernel,kernelModule::v_networkMapEntry, K_NETWORKMAPENTRY);
INITTYPE(kernel,kernelModule::v_spliced, K_SPLICED);
INITTYPE(kernel,kernelModule::v_configuration, K_CONFIGURATION);
INITTYPE(kernel,kernelModule::v_registration, K_REGISTRATION);
INITTYPE(kernel,kernelModule::v_historicalDataRequest,K_HISTORICALDATAREQUEST);
INITTYPE(kernel,kernelModule::v_persistentSnapshotRequest,K_PERSISTENTSNAPSHOTREQUEST);
INITTYPE(kernel,kernelModule::v_pendingDisposeElement,K_PENDINGDISPOSEELEMENT);
#undef INITTYPE
kernel->pendingDisposeList =
c_listNew(v_kernelType(kernel, K_PENDINGDISPOSEELEMENT ));
c_mutexInit(&kernel->pendingDisposeListMutex, SHARED_MUTEX);
kernelStatistics = v_kernelStatisticsNew(kernel);
v_observableInit(v_observable(kernel),
V_KERNEL_VERSION,
v_statistics(kernelStatistics),
TRUE);
c_lockInit(&kernel->lock,SHARED_LOCK);
kernel->qos = v_kernelQosNew(kernel, qos);
{
os_time time;
/* Fill GID with 'random' value */
memset(&kernel->GID, 0, sizeof(kernel->GID));
time = os_timeGet();
kernel->GID.systemId = time.tv_nsec;
}
kernel->participants = c_setNew(v_kernelType(kernel,K_PARTICIPANT));
kernel->partitions = c_tableNew(v_kernelType(kernel,K_DOMAIN),"name");
kernel->topics = c_tableNew(v_kernelType(kernel,K_TOPIC),"name");
kernel->groupSet = v_groupSetNew(kernel);
kernel->serviceManager = v_serviceManagerNew(kernel);
kernel->livelinessLM = v_leaseManagerNew(kernel);
kernel->configuration = NULL;
kernel->userCount = 1;
kernel->transactionCount = 0;
kernel->splicedRunning = TRUE;
kernel->maxSamplesWarnLevel = V_KERNEL_MAX_SAMPLES_WARN_LEVEL_DEF;
kernel->maxSamplesWarnShown = FALSE;
kernel->maxSamplesPerInstanceWarnLevel = V_KERNEL_MAX_SAMPLES_PER_INSTANCES_WARN_LEVEL_DEF;
kernel->maxSamplesPerInstanceWarnShown = FALSE;
kernel->maxInstancesWarnLevel = V_KERNEL_MAX_INSTANCES_WARN_LEVEL_DEF;
kernel->maxInstancesWarnShown = FALSE;
kernel->enabledStatisticsCategories =
c_listNew(c_resolve(base, "kernelModule::v_statisticsCategory"));
c_mutexInit(&kernel->sharesMutex, SHARED_MUTEX);
kernel->shares = c_tableNew(v_kernelType(kernel,K_SUBSCRIBER),
"qos.share.name");
kernel->crc = v_crcNew(kernel, V_CRC_KEY);
kernel->builtin = v_builtinNew(kernel);
kernel->deliveryService = NULL;
sd = v_splicedNew(kernel);
c_free(sd);
c_bind(kernel,name);
return kernel;
}
