// IShellIconOverlayIdentifier::GetOverlayInfo
// returns The Overlay Icon Location to the system
STDMETHODIMP CACloudSyncedRF::GetOverlayInfo(
LPWSTR pwszIconFile,
int cchMax,
int* pIndex,
DWORD* pdwFlags)
{
TCHAR logPath[MAX_PATH];
char logPathChar[MAX_PATH];
int result = ShlExtUtility::GetLogDirectory(logPath);
if (result == 0 ) {
result = ShlExtUtility::ConvertFromTString(logPath, logPathChar, MAX_PATH);
if (result == 0) {
LOGInit("pc_shellext", logPathChar);
int loglevel = ShlExtUtility::SetLogLevel();
LOG_INFO("logDirectoryString: %s, loglevel: %d", logPathChar, loglevel);
}
}
lastRecordedTime = NULL;
// Get our module's full path
GetModuleFileNameW(_AtlBaseModule.GetModuleInstance(), pwszIconFile, cchMax);
// Use first icon in the resource
*pIndex=0;
*pdwFlags = ISIOI_ICONFILE | ISIOI_ICONINDEX;
return S_OK;
}
static void LogInit(void) {
syscon_ahb_enable(SYSCON_CLK_IOCON);
LPC_IOCON->PIO1_6 |= (IOCON_FUNC1 | IOCON_MODE_PULLUP);
LPC_IOCON->PIO1_7 |= (IOCON_FUNC1 | IOCON_MODE_PULLUP);
LOGInit();
SYSLOG("The System Start Up[%s %s]\r\n", __DATE__, __TIME__);
}
int main(int argc, char *argv[])
{
LOGInit("HttpStringStreamTester", NULL);
LOGSetMax(0);
VPL_Init();
HttpStringStreamTester t;
t.RunTests();
exit(0);
}
int main(int argc, char ** argv)
#endif
{
#ifndef VPL_PLAT_IS_WINRT
LOGInit("test_ccd_sync", NULL);
LOGSetMax(0); // No limit
#endif
LOG_DISABLE_LEVEL(LOG_LEVEL_DEBUG);
VPL_Init();
LOG_INFO("TC_RESULT=PASS ;;; TC_NAME=old_ccd_sync_test(Deprecated)\n");
return 0;
}
int main(int argc, char** argv)
{
LOGInit("ccd_link_device", NULL);
LOGSetMax(0); // No limit
int rv;
{
rv = CCDITest_SetupCcdiTest();
if (rv != 0) {
LOG_ERROR("CCDITest_SetupCcdiTest failed: %d", rv);
goto out;
}
u64 userId = 0;
{
ccd::GetSystemStateInput req;
req.set_get_players(true);
ccd::GetSystemStateOutput resp;
rv = CCDIGetSystemState(req, resp);
if (rv != 0) {
LOG_ERROR("CCDIGetSystemState failed: %d", rv);
goto out;
} else {
userId = resp.players().players(0).user_id();
}
}
if (argc >= 2) {
LOG_INFO("Linking device");
ccd::LinkDeviceInput req;
req.set_user_id(userId);
req.set_device_name(argv[1]);
req.set_is_acer_device((argc > 2));
rv = CCDILinkDevice(req);
if (rv != 0) {
LOG_ERROR("CCDILinkDevice failed: %d", rv);
goto out;
}
} else {
LOG_INFO("Unlinking device");
ccd::UnlinkDeviceInput req;
req.set_user_id(userId);
rv = CCDIUnlinkDevice(req);
if (rv != 0) {
LOG_ERROR("CCDIUnlinkDevice failed: %d", rv);
goto out;
}
}
}
out:
// Since the return code usually ends up "mod 256", remap it to avoid ever returning 0 when
// something actually failed.
return (rv == 0) ? 0 : 255;
}
int main (int argc, char **argv)
{
const char * option_serialport = "/dev/gprs";
SerialPort * sp;
speed_t option_baud = B57600;
int b;
int count = MAXATTEMPTS;
int restartcount = MAXRESTARTCOUNT;
LOGInit(GWT_STDERR, GWL_INFO, "Glacsweb gsmat");
// set up rs232
sp = initialise(option_serialport, option_baud);
if (sp == NULL) {
return 1;
}
if( SERPutString(sp,"at\n\r") == 0) {
while(restartcount--){
while(count--){
b = SERGetByteTimeout(sp,2000000);
if( b == -1){
printf("timed out\n");
if( SERPutString(sp,"at\n") == 0) {
printf("put AT\n");
}else{
printf("put failed\n");
}
}else{
printf("got: %d after %d attempts %d powercycles\n", b, MAXATTEMPTS - count, MAXRESTARTCOUNT - restartcount);
SERFlushChannel(sp,100000);
return(0);
}
}
system("/home/root/scripts/gprs-off"); // Change path here to migrage to
//different system
usleep(5000000);
system("/home/root/scripts/gprs-on");
usleep(30000000);
}
}
else {
printf("failed to send AT\n");
return(-2);
}
return(1);
}
int main(int argc, char** argv)
{
LOGInit("ccd_register_storage_node", NULL);
LOGSetMax(0);
int rv;
{
rv = CCDITest_SetupCcdiTest();
if (rv != 0) {
LOG_ERROR("CCDITest_SetupCcdiTest failed: %d", rv);
goto out;
}
u64 userId = 0;
{
ccd::GetSystemStateInput req;
req.set_get_players(true);
ccd::GetSystemStateOutput resp;
rv = CCDIGetSystemState(req, resp);
if (rv != 0) {
LOG_ERROR("CCDIGetSystemState failed: %d", rv);
goto out;
} else {
userId = resp.players().players(0).user_id();
}
}
if (argc >= 2) {
LOG_INFO("Registering StorageNode");
ccd::RegisterStorageNodeInput req;
req.set_user_id(userId);
rv = CCDIRegisterStorageNode(req);
if (rv != 0) {
LOG_ERROR("CCDIRegisterStorageNode failed: %d", rv);
goto out;
}
} else {
LOG_INFO("Unregistering StorageNode");
ccd::UnregisterStorageNodeInput req;
req.set_user_id(userId);
rv = CCDIUnregisterStorageNode(req);
if (rv != 0) {
LOG_ERROR("CCDIUnregisterStorageNode failed: %d", rv);
goto out;
}
}
}
out:
// Since the return code usually ends up "mod 256", remap it to avoid ever returning 0 when
// something actually failed.
return (rv == 0) ? 0 : 255;
}
int main (int argc, char **argv)
{
LOGInit (argv[0], 0);
VPL_Init();
is_active = true;
db::object database;
sync::info sync_info;
task::processor tasks;
event::processor events;
events.default_handler (event::sleep_type, new exit_on_sleep);
events.default_handler (event::panic_type, new exit_on_panic);
events.default_handler (event::warn_type, new print_on_warn);
events.listen (event::wake_type, new setup_database_on_wake (database));
events.listen (event::wake_type, new setup_ccd_on_wake (sync_info));
events.listen (event::synced_type, new index_path_on_synced (database, sync_info.path));
events.listen (event::job_type, new enqueue_jobs (tasks));
events.listen (event::command_type, new command::user_interface (database, sync_info.path));
command_line_thread input (events);
ccd_notification_thread notify (events);
events.enqueue (new event::wake);
events.enqueue (new event::synced);
while (is_active)
{
events.dispatch ();
if (!tasks.execute ())
{
events.enqueue (new event::warn (tasks.log.errors.str ()));
tasks.log.errors.clear();
}
}
VPL_Quit();
return 0;
}
int main(int argc, char *argv[])
{
LOGInit("TestSyncDownJobs", NULL);
LOGSetMax(0);
LOG_DISABLE_LEVEL(LOG_LEVEL_DEBUG);
VPL_Init();
if (argc < 2) {
std::cerr << "Usage: " << argv[0] << " workdir" << std::endl;
exit(0);
}
std::string workdir = argv[1];
TestSyncDownJobs tsdj(workdir);
tsdj.RunTests();
exit(0);
}
int
main(int argc, char **argv)
{
char * region = (char *) getenv("region" );
char * client_user = (char *) getenv("client_user" );
char * client_device = (char *) getenv("client_device" );
char * server_user = (char *) getenv("server_user" );
char * server_device = (char *) getenv("server_device" );
char * server_instance = (char *) getenv("server_instance");
char * server_ans_blob = (char *) getenv("ans_blob" );
char * server_ans_key = (char *) getenv("ans_key" );
//pxd_declare_t declare; // TODO: remove
pxd_open_t open_client;
pxd_id_t client_id;
pxd_cred_t client_creds;
pxd_client_t * client;
pxd_open_t open_server;
pxd_id_t server_id;
pxd_cred_t server_creds;
ans_client_t * ans_client;
pxd_cred_t connect_creds;
pxd_connect_t connect;
pxd_error_t error;
mtwist_t mt;
//int lookup_result;
int tries;
//int lookup_tries;
int connect_tries;
uint32_t seed;
LOGInit("pxd_triangle", null);
pxd_host = (char *) getenv("pxd_host");
ans_host = (char *) getenv("ans_host");
if (pxd_host == null || ans_host == null || region == null) {
printf("pxd_host, ans_host, and region must be set.\n");
exit(1);
}
if (client_user == null || client_device == null) {
printf("client_user and client_device must be set.\n");
exit(1);
}
if (server_user == null || server_device == null || server_instance == null) {
printf("server_user, server_device, and server_instance must be set.\n");
exit(1);
}
if (server_ans_blob == null || server_ans_key == null) {
printf("ans_blob and ans_key must be set.\n");
exit(1);
}
seed = VPLTime_GetTime() ^ getpid();
mtwist_init(&mt, seed);
/*
* Set up the structures for opening a client connection.
*/
memset(&open_client, 0, sizeof(open_client ));
memset(&client_creds, 0, sizeof(client_creds));
memset(&client_id, 0, sizeof(client_id ));
open_client.cluster_name = pxd_host;
open_client.credentials = &client_creds;
open_client.credentials->id = &client_id;
open_client.credentials->key = client_key;
open_client.credentials->key_length = sizeof(client_key);
open_client.credentials->id->region = region;
open_client.credentials->id->instance_id = (char *) "CCD-client";
open_client.credentials->key = client_key;
open_client.credentials->key_length = sizeof(client_key);
/*
* Now open the client CCD connection.
*/
client = do_open(&open_client, client_user, client_device, false);
free(open_client.credentials->opaque);
open_client.credentials->opaque = null;
/*
* Okay, open the server CCD connection.
*/
server_info = &open_server;
memset(&open_server, 0, sizeof(open_server ));
memset(&server_creds, 0, sizeof(server_creds));
memset(&server_id, 0, sizeof(server_id ));
open_server.cluster_name = pxd_host;
open_server.credentials = &server_creds;
open_server.credentials->id = &server_id;
open_server.credentials->key = server_key;
open_server.credentials->key_length = sizeof(server_key);
open_server.credentials->id->region = region;
open_server.credentials->id->instance_id = server_instance;
open_server.credentials->key = server_key;
open_server.credentials->key_length = sizeof(server_key);
server = do_open(&open_server, server_user, server_device, true );
free(open_server.credentials->opaque);
open_server.credentials->opaque = null;
if (client == null || server == null) {
error("A pxd_open operation failed.\n");
exit(1);
}
ans_client = open_ans(open_server.credentials, ans_host, server_ans_blob, server_ans_key);
VPLThread_Sleep(VPLTime_FromMillisec(1000));
/*
* Declare the server CCD to the PXD demon.
*/
/*memset(&declare, 0, sizeof(declare ));
memset(&ip_address, 0, sizeof(ip_address));
declare.ans_dns = ans_host;
declare.pxd_dns = pxd_host;
declare.address_count = 1;
declare.addresses[0].ip_address = ip_address; // not used
declare.addresses[0].ip_length = sizeof(ip_address);
declare.addresses[0].port = 8;
pxd_declare(server, &declare, &error);
if (error.error != 0) {
error("pxd_declare failed: %s.\n", error.message);
exit(1);
}*/
/*
* Now try a lookup of the server CCD on the CCD client side.
* The lookup should cause PXD to send a server wakeup message
* to the server side.
*/
/*lookup_tries = 4;
log("Starting the pxd_lookup attempts.\n");
do {
lookup_result = -1;
pxd_lookup(client, &server_id, &lookup_result, &error);
if (error.error != 0) {
error("pxd_lookup failed: %s.\n", error.message);
exit(1);
}
tries = 40;
while (lookup_result < 0 && tries-- > 0) {
VPLThread_Sleep(VPLTime_FromMillisec(100));
}
if (lookup_result != pxd_op_successful) {
sleep(1);
}
} while (lookup_tries-- > 0 && lookup_result != pxd_op_successful);
if (lookup_result != pxd_op_successful) {
error("pxd_lookup failed: %s (%d).\n",
pxd_string(lookup_result), (int) lookup_result);
exit(1);
}*/
/*
* Start the connection attempt.
*/
memset(&connect, 0, sizeof(connect ));
memset(&connect_creds, 0, sizeof(connect_creds));
connect.target = server_info->credentials->id;
connect.creds = &connect_creds;
connect.pxd_dns = lookup_host;
connect.creds->id = &client_id;
connect.creds->key = session_key;
connect.creds->key_length = sizeof(session_key);
make_ccd_creds(connect.target, connect.creds);
/*
* Now add the address. It's not used yet, so its content is irrelevant,
* and I might not even need to set it.
*/
connect.address_count = 1;
connect.addresses[0].ip_address = saved_address;
connect.addresses[0].ip_length = saved_length;
connect.addresses[0].port = 7000;
connect_tries = 3;
do {
connect_finished = false;
log("calling pxd_connect\n");
pxd_connect(client, &connect, &error);
if (error.error != 0) {
error("pxd_connect failed: %s.\n", error.message);
exit(1);
}
/*
* The connection setup might be done on the server, with
* some look. So start trying receive operations. We don't
* have ANS providing synchronization, so we need to give
* it a few shots.
*/
tries = 10;
while ((!connect_finished || incoming_logins == 0) && tries-- > 0) {
sleep(1);
}
if (!connect_finished) {
error("The proxy connection operation didn't complete.\n");
exit(1);
}
log(" === A connect operation completed.\n");
} while (!connect_passed && connect_tries-- > 0);
tries = 5;
free(connect.creds->opaque);
connect.creds->opaque = null;
while (incoming_logins == 0 && tries-- > 0) {
sleep(1);
}
/*
* At this point, we should have received the callback for the
* connection attempt and an incoming login.
*/
if (!connect_passed || incoming_logins == 0) {
error("The proxy connection operation didn't complete or didn't pass.\n");
error("connect_finished: %d, connect_passed %d, incoming_logins %d\n",
(int) connect_finished, (int) connect_passed, (int) incoming_logins);
exit(1);
}
log(" === The connect operation succeeded.\n");
pxd_close(&client, true, &error);
if (error.error != 0) {
error("The client close failed: %s.\n", error.message);
exit(1);
}
pxd_close(&server, true, &error);
if (error.error != 0) {
error("The server close failed: %s.\n", error.message);
exit(1);
}
ans_close(ans_client, true);
free(lookup_host);
pxd_free_address(&server_address);
sleep(1); // Wait for the threads to exit (we hope)
printf("The pxd triangle test passed.\n");
return 0;
}
//------------------------------------------------------------------------
void _cdecl FP_FILELog(LPCSTR msg,...)
{
FILE *f;
BOOL first;
va_list argptr;
char str[3000],*m;
DWORD err = GetLastError();
if(!msg) return;
first = LOGInit();
EnterCriticalSection(&PLOG_cs);
m = (char*)FP_GetLogFullFileName();
f = (m && *m) ? fopen(m,first?"w":"a") : NULL;
if(f)
{
//Time
static SYSTEMTIME stOld = { 0 };
SYSTEMTIME st;
GetLocalTime(&st);
fprintf(f,"%4d.%02d.%02d %02d:%02d:%02d:%04d ",
st.wYear, st.wMonth, st.wDay,
st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
if(!stOld.wYear)
fprintf(f,"---- ");
else
fprintf(f,"%04d ",
(st.wSecond-stOld.wSecond)*1000 + (st.wMilliseconds-stOld.wMilliseconds));
stOld = st;
//Error
if(FP_LogErrorStringLength)
{
SetLastError(err);
StrCpy(str,__WINError(),FP_LogErrorStringLength);
if((m=strchr(str,'\n')) != NULL) *m = 0;
if((m=strchr(str,'\r')) != NULL) *m = 0;
fprintf(f,"%-*s->",FP_LogErrorStringLength,str);
}
else
fprintf(f,"->");
//Message
StrCpy(str,msg,sizeof(str));
if((m=strchr(str,'\n')) != NULL) *m = 0;
if((m=strchr(str,'\r')) != NULL) *m = 0;
va_start(argptr, msg);
vfprintf(f,str,argptr);
va_end(argptr);
//EOL
fprintf(f,"\n");
fclose(f);
}
LeaveCriticalSection(&PLOG_cs);
SetLastError(err);
}
int
main(int argc, char **argv)
{
bool retVal;
gboolean debug = FALSE;
gboolean fake_battery = FALSE;
gboolean visual_leds_suspend = FALSE;
gboolean verbose = FALSE;
gboolean err_on_crit = FALSE;
gboolean fasthalt = FALSE;
gint maxtemp = 0;
gint temprate = 0;
GOptionEntry entries[] = {
{"debug", 'd', 0, G_OPTION_ARG_NONE, &debug, "turn debug logging on", NULL},
{"use-fake-battery", 'b', 0, G_OPTION_ARG_NONE, &fake_battery, "Use fake battery", NULL},
{"visual-leds-suspend", 'l', 0, G_OPTION_ARG_NONE, &visual_leds_suspend, "Use LEDs to show wake/suspend state", NULL},
{"verbose-syslog", 'v', 0, G_OPTION_ARG_NONE, &verbose, "Use Verbose syslog output", NULL},
{"error-on-critical", 'e', 0, G_OPTION_ARG_NONE, &err_on_crit, "Crash on critical error", NULL},
{"maxtemp", 'M', 0, G_OPTION_ARG_INT, &maxtemp, "Set maximum temperature before shutdown (default 60)", NULL},
{"temprate", 'T', 0, G_OPTION_ARG_INT, &temprate, "Expected maxiumum temperature slew rate (default 12)", NULL},
{"fasthalt", 'F', 0, G_OPTION_ARG_NONE, &fasthalt, "On overtemp, shut down quickly not cleanly", NULL},
{ NULL }
};
GError *error = NULL;
GOptionContext *ctx;
ctx = g_option_context_new(" - power daemon");
g_option_context_add_main_entries(ctx, entries, NULL);
if (!g_option_context_parse(ctx, &argc, &argv, &error)) {
g_critical("option parsing failed: %s", error->message);
exit(1);
}
// FIXME integrate this into TheOneInit()
LOGInit();
LOGSetHandler(LOGSyslog);
if (debug) {
powerd_debug = true;
LOGSetLevel(G_LOG_LEVEL_DEBUG);
LOGSetHandler(LOGGlibLog);
}
signal(SIGTERM, term_handler);
signal(SIGINT, term_handler);
if (!g_thread_supported ()) g_thread_init (NULL);
mainloop = g_main_loop_new(NULL, FALSE);
/**
* initialize the lunaservice and we want it before all the init
* stuff happening.
*/
LSError lserror;
LSErrorInit(&lserror);
retVal = LSRegisterPalmService("com.palm.power", &psh, &lserror);
if (!retVal)
{
goto ls_error;
}
retVal = LSGmainAttachPalmService(psh, mainloop, &lserror);
if (!retVal)
{
goto ls_error;
}
private_sh = LSPalmServiceGetPrivateConnection(psh);
/**
* Calls the init functions of all the modules in priority order.
*/
TheOneInit();
g_main_loop_run(mainloop);
end:
g_main_loop_unref(mainloop);
// save time before quitting...
timesaver_save();
return 0;
ls_error:
g_critical("Fatal - Could not initialize powerd. Is LunaService Down?. %s",
lserror.message);
LSErrorFree(&lserror);
goto end;
}
int
main(int argc, char **argv)
{
bool retVal;
// FIXME integrate this into TheOneInit()
LOGInit();
LOGSetHandler(LOGSyslog);
signal(SIGTERM, term_handler);
signal(SIGINT, term_handler);
if (!g_thread_supported ()) g_thread_init (NULL);
mainloop = g_main_loop_new(NULL, FALSE);
/**
* initialize the lunaservice and we want it before all the init
* stuff happening.
*/
LSError lserror;
LSErrorInit(&lserror);
retVal = LSRegisterPalmService("com.palm.sleep", &psh, &lserror);
if (!retVal)
{
goto ls_error;
}
retVal = LSGmainAttachPalmService(psh, mainloop, &lserror);
if (!retVal)
{
goto ls_error;
}
private_sh = LSPalmServiceGetPrivateConnection(psh);
retVal = LSCall(private_sh,"luna://com.palm.lunabus/signal/addmatch","{\"category\":\"/com/palm/power\","
"\"method\":\"USBDockStatus\"}", ChargerStatus, NULL, NULL, &lserror);
if (!retVal) {
SLEEPDLOG(LOG_CRIT,"Error in registering for luna-signal \"chargerStatus\"");
goto ls_error;
}
int ret = nyx_device_open(NYX_DEVICE_SYSTEM, "Main", &nyxSystem);
if(ret != NYX_ERROR_NONE)
{
SLEEPDLOG(LOG_CRIT,"Sleepd: Unable to open the nyx device system");
abort();
}
TheOneInit();
LSCall(private_sh,"luna://com.palm.power/com/palm/power/chargerStatusQuery","{}",ChargerStatus,NULL,NULL,&lserror);
SLEEPDLOG(LOG_INFO,"Sleepd daemon started\n");
g_main_loop_run(mainloop);
end:
g_main_loop_unref(mainloop);
return 0;
ls_error:
SLEEPDLOG(LOG_CRIT,"Fatal - Could not initialize sleepd. Is LunaService Down?. %s",
lserror.message);
LSErrorFree(&lserror);
goto end;
}
int _tmain(int argc, _TCHAR* argv[])
{
LOGInit("ccdi_client_sanity_test", "C:\\temp\\igware");
LOGSetMax(0); // no limit
//LOGSetWriteToStdout(VPL_FALSE);
LOG_INFO("START");
VPL_RegisterDebugCallback(debugCallback);
int rv;
{
ccd::GetInfraHttpInfoInput request;
request.set_service(ccd::INFRA_HTTP_SERVICE_OPS);
request.set_secure(true);
ccd::GetInfraHttpInfoOutput response;
rv = CCDIGetInfraHttpInfo(request, response);
printf("CCDIGetInfraHttpInfo returned %d\n", rv);
if (rv < 0) {
goto end;
}
printf(" prefix: %s\n", response.url_prefix().c_str());
}
u64 userId = 0;
{
ccd::LoginInput request;
request.set_user_name(USERNAME);
request.set_password(PASSWORD);
ccd::LoginOutput response;
rv = CCDILogin(request, response);
printf("CCDILogin returned %d\n", rv);
if (rv < 0) {
goto end;
}
userId = response.user_id();
printf(" userId: "FMT_VPLUser_Id_t"\n", userId);
}
{
ccd::GetInfraHttpInfoInput request;
request.set_service(ccd::INFRA_HTTP_SERVICE_OPS);
request.set_secure(true);
request.set_user_id(userId);
ccd::GetInfraHttpInfoOutput response;
rv = CCDIGetInfraHttpInfo(request, response);
printf("CCDIGetInfraHttpInfo returned %d\n", rv);
if (rv < 0) {
goto end;
}
printf(" prefix: %s\n", response.url_prefix().c_str());
}
rv = CallGetSyncState(userId);
if (rv < 0) {
goto end;
}
{
ccd::LinkDeviceInput request;
request.set_user_id(userId);
request.set_is_acer_device(true);
request.set_device_name("My test PC");
rv = CCDILinkDevice(request);
printf("CCDILinkDevice returned %d\n", rv);
if (rv < 0) {
goto end;
}
}
{
ccd::ListLinkedDevicesInput request;
request.set_user_id(userId);
ccd::ListLinkedDevicesOutput response;
rv = CCDIListLinkedDevices(request, response);
printf("CCDIListLinkedDevices returned %d\n", rv);
if (rv < 0){
goto end;
}
printf("response (%d):\n----\n%s----\n", response.devices_size(), response.DebugString().c_str());
}
VPLThread_Sleep(VPLTime_FromSec(3));
{
ccd::ListLinkedDevicesInput request;
request.set_user_id(userId);
ccd::ListLinkedDevicesOutput response;
rv = CCDIListLinkedDevices(request, response);
printf("CCDIListLinkedDevices returned %d\n", rv);
if (rv < 0){
goto end;
}
printf("response (%d):\n----\n%s----\n", response.devices_size(), response.DebugString().c_str());
}
{
ccd::ListOwnedDatasetsInput request;
request.set_user_id(userId);
ccd::ListOwnedDatasetsOutput response;
rv = CCDIListOwnedDatasets(request, response);
printf("CCDIListOwnedDatasets returned %d\n", rv);
if (rv < 0){
goto end;
}
for (int i = 0; i < response.dataset_details_size(); i++) {
ccd::GetDatasetDirectoryEntriesInput request2;
u64 datasetId = response.dataset_details(i).datasetid();
if (i == 0) {
ccd::AddSyncSubscriptionInput request3;
request3.set_user_id(userId);
request3.set_dataset_id(datasetId);
request3.set_subscription_type(ccd::SUBSCRIPTION_TYPE_NORMAL);
rv = CCDIAddSyncSubscription(request3);
printf("CCDIAddSyncSubscription returned %d\n", rv);
}
request2.set_dataset_id(datasetId);
request2.set_user_id(userId);
request2.set_directory_name("/");
ccd::GetDatasetDirectoryEntriesOutput response2;
rv = CCDIGetDatasetDirectoryEntries(request2, response2);
printf("CCDIGetDatasetDirectoryEntries returned %d\n", rv);
if (rv < 0){
goto end;
}
for (int j = 0; j < response2.entries_size(); j++) {
printf(" dataset[%d]("FMTx64")[%d] = %s%s\n",
i, datasetId, j,
response2.entries(j).name().c_str(),
(response2.entries(j).is_dir() ? "/" : ""));
}
}
}
end:
{
ccd::LogoutInput request;
int logoutErr = CCDILogout(request);
printf("CCDILogout returned %d\n", logoutErr);
}
return (rv != 0);
}
