rdpRdp* rdp_new(freerdp* instance)
{
rdpRdp* rdp;
rdp = (rdpRdp*) xzalloc(sizeof(rdpRdp));
if (rdp != NULL)
{
rdp->instance = instance;
rdp->settings = settings_new((void*) instance);
if (instance != NULL)
instance->settings = rdp->settings;
rdp->extension = extension_new(instance);
rdp->transport = transport_new(rdp->settings);
rdp->license = license_new(rdp);
rdp->input = input_new(rdp);
rdp->update = update_new(rdp);
rdp->fastpath = fastpath_new(rdp);
rdp->nego = nego_new(rdp->transport);
rdp->mcs = mcs_new(rdp->transport);
rdp->redirection = redirection_new();
rdp->mppc = mppc_new(rdp);
}
return rdp;
}
TEST_F(LoggingTests, BasicLogManagerTest) {
peloton_logging_mode = LOGGING_TYPE_INVALID;
auto &log_manager = logging::LogManager::GetInstance();
log_manager.DropFrontendLoggers();
log_manager.SetLoggingStatus(LOGGING_STATUS_TYPE_INVALID);
// just start, write a few records and exit
catalog::Schema *table_schema = new catalog::Schema(
{ExecutorTestsUtil::GetColumnInfo(0), ExecutorTestsUtil::GetColumnInfo(1),
ExecutorTestsUtil::GetColumnInfo(2),
ExecutorTestsUtil::GetColumnInfo(3)});
std::string table_name("TEST_TABLE");
// Create table.
bool own_schema = true;
bool adapt_table = false;
storage::DataTable *table = storage::TableFactory::GetDataTable(
12345, 123456, table_schema, table_name, 1, own_schema, adapt_table);
storage::Database test_db(12345);
test_db.AddTable(table);
catalog::Manager::GetInstance().AddDatabase(&test_db);
concurrency::TransactionManager &txn_manager =
concurrency::TransactionManagerFactory::GetInstance();
txn_manager.BeginTransaction();
ExecutorTestsUtil::PopulateTable(table, 5, true, false, false);
txn_manager.CommitTransaction();
peloton_logging_mode = LOGGING_TYPE_NVM_WAL;
log_manager.SetSyncCommit(true);
EXPECT_FALSE(log_manager.ContainsFrontendLogger());
log_manager.StartStandbyMode();
log_manager.GetFrontendLogger(0)->SetTestMode(true);
log_manager.StartRecoveryMode();
log_manager.WaitForModeTransition(LOGGING_STATUS_TYPE_LOGGING, true);
EXPECT_TRUE(log_manager.ContainsFrontendLogger());
log_manager.SetGlobalMaxFlushedCommitId(4);
concurrency::Transaction test_txn;
cid_t commit_id = 5;
log_manager.PrepareLogging();
log_manager.LogBeginTransaction(commit_id);
ItemPointer insert_loc(table->GetTileGroup(1)->GetTileGroupId(), 0);
ItemPointer delete_loc(table->GetTileGroup(2)->GetTileGroupId(), 0);
ItemPointer update_old(table->GetTileGroup(3)->GetTileGroupId(), 0);
ItemPointer update_new(table->GetTileGroup(4)->GetTileGroupId(), 0);
log_manager.LogInsert(commit_id, insert_loc);
log_manager.LogUpdate(commit_id, update_old, update_new);
log_manager.LogInsert(commit_id, delete_loc);
log_manager.LogCommitTransaction(commit_id);
// TODO: Check the flushed commit id
// since we are doing sync commit we should have reached 5 already
//EXPECT_EQ(commit_id, log_manager.GetPersistentFlushedCommitId());
log_manager.EndLogging();
}
rdpRdp* rdp_new(rdpContext* context)
{
rdpRdp* rdp;
DWORD flags;
rdp = (rdpRdp*) malloc(sizeof(rdpRdp));
if (rdp)
{
ZeroMemory(rdp, sizeof(rdpRdp));
rdp->context = context;
rdp->instance = context->instance;
flags = 0;
if (context->ServerMode)
flags |= FREERDP_SETTINGS_SERVER_MODE;
if (!context->settings)
context->settings = freerdp_settings_new(flags);
rdp->settings = context->settings;
rdp->settings->instance = context->instance;
if (context->instance)
context->instance->settings = rdp->settings;
rdp->extension = extension_new(context->instance);
rdp->transport = transport_new(rdp->settings);
rdp->transport->rdp = rdp;
rdp->license = license_new(rdp);
rdp->input = input_new(rdp);
rdp->update = update_new(rdp);
rdp->fastpath = fastpath_new(rdp);
rdp->nego = nego_new(rdp->transport);
rdp->mcs = mcs_new(rdp->transport);
rdp->redirection = redirection_new();
rdp->autodetect = autodetect_new();
rdp->heartbeat = heartbeat_new();
rdp->multitransport = multitransport_new();
rdp->bulk = bulk_new(context);
}
return rdp;
}
rdpRdp* rdp_new()
{
rdpRdp* rdp;
rdp = (rdpRdp*) xzalloc(sizeof(rdpRdp));
if (rdp != NULL)
{
rdp->licensed = False;
rdp->settings = settings_new();
rdp->registry = registry_new(rdp->settings);
rdp->transport = transport_new(rdp->settings);
rdp->license = license_new(rdp);
rdp->input = input_new(rdp);
rdp->update = update_new(rdp);
rdp->nego = nego_new(rdp->transport);
rdp->mcs = mcs_new(rdp->transport);
}
return rdp;
}
void test_update_recv_orders(void)
{
rdpRdp* rdp;
STREAM _s, *s;
rdpUpdate* update;
s = &_s;
rdp = rdp_new(NULL);
update = update_new(rdp);
update->context = malloc(sizeof(rdpContext));
update->context->rdp = rdp;
opaque_rect_count = 0;
polyline_count = 0;
patblt_count = 0;
update->primary->OpaqueRect = test_opaque_rect;
update->primary->Polyline = test_polyline;
update->primary->PatBlt = test_patblt;
s->p = s->data = orders_update_1;
s->size = sizeof(orders_update_1);
update_recv(update, s);
CU_ASSERT(opaque_rect_count == 5);
CU_ASSERT(polyline_count == 2);
update->primary->order_info.orderType = ORDER_TYPE_PATBLT;
s->p = s->data = orders_update_2;
s->size = sizeof(orders_update_2);
update_recv(update, s);
CU_ASSERT(patblt_count == 3);
free(update->context);
}
rdpRdp* rdp_new(rdpContext* context)
{
rdpRdp* rdp;
DWORD flags;
BOOL newSettings = FALSE;
rdp = (rdpRdp*) calloc(1, sizeof(rdpRdp));
if (!rdp)
return NULL;
rdp->context = context;
rdp->instance = context->instance;
flags = 0;
if (context->ServerMode)
flags |= FREERDP_SETTINGS_SERVER_MODE;
if (!context->settings)
{
context->settings = freerdp_settings_new(flags);
if (!context->settings)
goto out_free;
newSettings = TRUE;
}
rdp->settings = context->settings;
rdp->settings->instance = context->instance;
if (context->instance)
context->instance->settings = rdp->settings;
rdp->transport = transport_new(rdp->settings);
if (!rdp->transport)
goto out_free_settings;
rdp->transport->rdp = rdp;
rdp->license = license_new(rdp);
if (!rdp->license)
goto out_free_transport;
rdp->input = input_new(rdp);
if (!rdp->input)
goto out_free_license;
rdp->update = update_new(rdp);
if (!rdp->update)
goto out_free_input;
rdp->fastpath = fastpath_new(rdp);
if (!rdp->fastpath)
goto out_free_update;
rdp->nego = nego_new(rdp->transport);
if (!rdp->nego)
goto out_free_fastpath;
rdp->mcs = mcs_new(rdp->transport);
if (!rdp->mcs)
goto out_free_nego;
rdp->redirection = redirection_new();
if (!rdp->redirection)
goto out_free_mcs;
rdp->autodetect = autodetect_new();
if (!rdp->autodetect)
goto out_free_redirection;
rdp->heartbeat = heartbeat_new();
if (!rdp->heartbeat)
goto out_free_autodetect;
rdp->multitransport = multitransport_new();
if (!rdp->multitransport)
goto out_free_heartbeat;
rdp->bulk = bulk_new(context);
if (!rdp->bulk)
goto out_free_multitransport;
return rdp;
out_free_multitransport:
multitransport_free(rdp->multitransport);
out_free_heartbeat:
heartbeat_free(rdp->heartbeat);
out_free_autodetect:
autodetect_free(rdp->autodetect);
out_free_redirection:
redirection_free(rdp->redirection);
out_free_mcs:
mcs_free(rdp->mcs);
out_free_nego:
nego_free(rdp->nego);
out_free_fastpath:
fastpath_free(rdp->fastpath);
out_free_update:
update_free(rdp->update);
out_free_input:
input_free(rdp->input);
out_free_license:
license_free(rdp->license);
out_free_transport:
transport_free(rdp->transport);
out_free_settings:
if (newSettings)
freerdp_settings_free(rdp->settings);
out_free:
free(rdp);
return NULL;
}
int cardpeek_update_perform(void)
{
const char* cardpeek_update_file = path_config_get_string(PATH_CONFIG_FILE_CARDPEEK_UPDATE);
a_string_t *contents;
update_t *update;
int remove;
update_item_t *item;
time_t now = time(NULL);
int updated = 0;
char *url = NULL;
char *local_file;
char *local_dnld;
unsigned char digest[SHA256_DIGEST_LENGTH];
a_string_t *url_request;
unsigned first_update;
first_update = (unsigned)luax_variable_get_integer("cardpeek.updates.first_update");
/* STEP 1: get cardpeek.update file */
url=luax_variable_get_strdup("cardpeek.updates.url");
if (url==NULL)
url = g_strdup(DEFAULT_UPDATE_URL);
log_printf(LOG_INFO,"Fetching '%s'",url);
url_request = a_strnew(NULL);
a_sprintf(url_request,"%s?u=%x&v=%s",url,first_update,VERSION);
if (http_download(a_strval(url_request),cardpeek_update_file)==0)
{
g_free(url);
return 0;
}
g_free(url);
a_strfree(url_request);
/* STEP 2: parse file */
if ((contents=file_get_contents(cardpeek_update_file))==NULL)
{
log_printf(LOG_ERROR,"failed to read update file information.");
unlink(cardpeek_update_file);
return 0;
}
update = update_new();
if ((update_load(update,a_strval(contents),a_strlen(contents)))==0)
{
unlink(cardpeek_update_file);
a_strfree(contents);
update_free(update);
return 0;
}
a_strfree(contents);
/* log_printf(LOG_DEBUG,"Updates correctly loaded from '%s'",cardpeek_update_file); */
if ((remove = update_filter_version(update,VERSION))>0)
log_printf(LOG_WARNING,"%d updates will not be installed because they require a newer version of Cardpeek.");
remove = update_filter_files(update);
if (update->item_count)
log_printf(LOG_INFO,"A total of %d files will be updated, %d files are kept unchanged.",update->item_count,remove);
else
log_printf(LOG_INFO,"No files will be updated, %d files are kept unchanged.",remove);
item = update->items;
while (item)
{
local_dnld = new_path(PATH_CONFIG_FOLDER_CARDPEEK,item->file,".download");
local_file = new_path(PATH_CONFIG_FOLDER_CARDPEEK,item->file,NULL);
if (http_download(item->url,local_dnld)!=0)
{
if (sha256sum(local_dnld,digest))
{
if (memcmp(digest,bytestring_get_data(&item->digest),SHA256_DIGEST_LENGTH)==0)
{
unlink(local_file);
if (rename(local_dnld,local_file)==0)
{
log_printf(LOG_INFO,"Successfuly updated %s", local_file);
updated++;
}
else
{
log_printf(LOG_ERROR,"Failed to copy %s to %s: %s",
local_dnld,
local_file,
strerror(errno));
}
}
else
{
log_printf(LOG_WARNING,"File %s was not updated: authentication failed.",local_file);
}
}
unlink(local_dnld);
}
g_free(local_dnld);
g_free(local_file);
item = item->next;
}
if (updated == update->item_count)
{
luax_variable_set_integer("cardpeek.updates.next_update",(int)(now+7*(24*3600)));
luax_config_table_save();
}
unlink(cardpeek_update_file);
update_free(update);
/* STEP 3: finish */
return 1;
}
