int main(){
apisock *sock;
binresult *res;
sock=api_connect();
if (!sock){
fprintf(stderr, "Cannot connect to server\n");
return 1;
}
res=send_command(sock, "userinfo", P_STR("auth", "Ec7QkEjFUnzZ7Z8W2YH1qLgxY7gGvTe09AH0i7V3kX"));
if (!res){
fprintf(stderr, "Command failed\n");
return 1;
}
print_tree(res, 0);
free(res);
res=send_command(sock, "diff", P_NUM("folderid", 0), P_BOOL("recursive", 1), P_STR("timeformat", "timestamp"));
if (!res){
fprintf(stderr, "Command failed\n");
return 1;
}
print_tree(res, 0);
free(res);
return 0;
send_command_nb(sock, "diff", P_NUM("diffid", 0));
res=get_result(sock);
if (!res){
fprintf(stderr, "Command failed\n");
return 1;
}
print_tree(res, 0);
// printf("%u %llu\n", res->type, res->num);
free(res);
api_close(sock);
return 0;
}
static int psync_p2p_get_download_token(psync_fileid_t fileid, const unsigned char *filehashhex, uint64_t fsize, unsigned char **token, size_t *tlen){
binparam params[]={P_STR("auth", psync_my_auth), P_NUM("fileid", fileid), P_NUM("filesize", fsize),
P_LSTR(PSYNC_CHECKSUM, filehashhex, PSYNC_HASH_DIGEST_HEXLEN),
P_LSTR("keydata", psync_rsa_public_bin->data, psync_rsa_public_bin->datalen)};
psync_socket *api;
binresult *res;
const binresult *ctoken;
*token=NULL; /* especially for gcc */
*tlen=0;
api=psync_apipool_get();
if (unlikely_log(!api))
return PSYNC_NET_TEMPFAIL;
res=send_command(api, "getfileownershiptoken", params);
if (unlikely_log(!res)){
psync_apipool_release_bad(api);
return PSYNC_NET_TEMPFAIL;
}
psync_apipool_release(api);
if (unlikely_log(psync_find_result(res, "result", PARAM_NUM)->num!=0)){
psync_free(res);
return PSYNC_NET_PERMFAIL;
}
ctoken=psync_find_result(res, "token", PARAM_STR);
*token=psync_malloc(ctoken->length+1);
memcpy(*token, ctoken->str, ctoken->length+1);
*tlen=ctoken->length;
psync_free(res);
return PSYNC_NET_OK;
}
int main(void)
{
TASK *cdc_demo_task_cb;
/* Initialize scheduler. */
scheduler_init();
/* Initialize memory. */
mem_init();
/* Initialize file system. */
fs_init();
/* Initialize USB stack. */
usb_init();
/* Initialize serial. */
serial_init();
/* Create a task for CDC demo. */
cdc_demo_task_cb = (TASK *)mem_static_alloc(sizeof(TASK) + 4096);
task_create(cdc_demo_task_cb, P_STR("CDCDEMO"), (uint8_t *)(cdc_demo_task_cb + 1), 4096, &cdc_demo_task, (void *)(NULL));
scheduler_task_add(cdc_demo_task_cb, 5);
/* Run scheduler. */
kernel_run();
return (0);
}
void cache_ba_my_teams() {
psync_socket *sock;
binresult *bres;
int i;
const binresult *users;
const binresult *user;
const binresult *teams;
psync_sql_res *q;
psync_sql_lock();
q=psync_sql_prep_statement("DELETE FROM myteams ");
psync_sql_run_free(q);
binparam params[] = { P_STR("auth", psync_my_auth), P_STR("timeformat", "timestamp"), P_STR("userids", "me"), P_STR("showteams", "1"), P_STR("showeveryone", "1") };
sock = psync_apipool_get();
bres = send_command(sock, "account_users", params);
if (likely(bres))
psync_apipool_release(sock);
else {
psync_apipool_release_bad(sock);
debug(D_WARNING, "Send command returned invalid result.\n");
return;
}
users = psync_find_result(bres, "users", PARAM_ARRAY);
if (!users->length) {
psync_free(bres);
debug(D_WARNING, "Account_users returned empty result!\n");
return;
} else {
user = users->array[0];
teams = psync_find_result(user, "teams", PARAM_ARRAY);
if (teams->length) {
for (i = 0; i < teams->length; ++i)
cache_my_team(teams->array[i]);
}
}
psync_free(bres);
psync_sql_unlock();
}
inline stlsoft::basic_shim_string<pantheios::pan_char_t>
c_str_data_t_(Thingy const &thingy)
{
stlsoft::basic_shim_string<pantheios::pan_char_t> s(50);
int cch = pan_sprintf_(s.data(), P_STR("0x%p"), static_cast<void const*>(&thingy));
s.truncate(static_cast<size_t>(cch));
return s;
}
static void fwheel_connect(struct indi_prop_t *iprop, void *callback_data)
{
struct fwheel_t *fwheel = (struct fwheel_t *)callback_data;
if (strcmp(iprop->name, "FILTER_SLOT") == 0) {
d4_printf("Found FILTER_SLOT for filter wheel %s\n", iprop->idev->name);
fwheel->filter_slot_prop = iprop;
indi_prop_add_cb(iprop, (IndiPropCB)fwheel_slot_update, fwheel);
}
else
INDI_try_dev_connect(iprop, INDI_COMMON (fwheel), P_STR(INDI_FWHEEL_PORT));
fwheel_check_state(fwheel);
}
void DirectoryPickerDialog::showEvent(QShowEvent *)
{
QList<QTreeWidgetItem *> items;
apisock *conn;
binresult *res, *result, *rn;
binresult root;
QByteArray auth=app->settings->get("auth").toUtf8();
if (!(conn=app->getAPISock())){
showError("Could not connect to server. Check your Internet connection.");
return;
}
ui->dirtree->clear();
ui->dirtree->setColumnCount(1);
ui->dirtree->setHeaderLabels(QStringList("Name"));
res=send_command(conn, "listfolder",
P_LSTR("auth", auth.constData(), auth.size()),
P_STR("filtermeta", "contents,folderid,name"),
P_NUM("folderid", 0),
P_BOOL("recursive", 1),
P_BOOL("nofiles", 1),
P_BOOL("noshares", onlyMine));
api_close(conn);
result=find_res(res, "result");
if (!result){
showError("Could not connect to server. Check your Internet connection.");
free(res);
return;
}
if (result->num!=0){
showError(find_res(res, "error")->str);
free(res);
return;
}
if (showRoot){
root.type=PARAM_ARRAY;
root.length=1;
root.array=&rn;
rn=find_res(res, "metadata");
result=&root;
}
else
result=find_res(find_res(res, "metadata"), "contents");
items=binresToQList(result);
ui->dirtree->insertTopLevelItems(0, items);
ui->dirtree->sortByColumn(0, Qt::AscendingOrder);
if (items.count()){
ui->dirtree->setCurrentItem(items[0]);
ui->dirtree->expandItem(items[0]);
}
free(res);
}
static inline int
resolve_pfx_str(struct ud* u)
{
if (u->pfx_str == 0xf3) {
if (P_STR(u->itab_entry->prefix)) {
u->pfx_rep = 0xf3;
} else {
u->pfx_repe = 0xf3;
}
} else if (u->pfx_str == 0xf2) {
u->pfx_repne = 0xf3;
}
return 0;
}
struct camera_t *camera_find(void *window, int type)
{
struct camera_t *camera;
struct indi_t *indi;
if (type == CAMERA_MAIN) {
camera = (struct camera_t *)g_object_get_data(G_OBJECT(window), "camera-main");
} else {
camera = (struct camera_t *)g_object_get_data(G_OBJECT(window), "camera-guide");
}
if (camera) {
if (camera->ready) {
d4_printf("Found camera\n");
return camera;
}
return NULL;
}
if (! (indi = INDI_get_indi(window)))
return NULL;
camera = g_new0(struct camera_t, 1);
if (type == CAMERA_MAIN) {
INDI_common_init(INDI_COMMON (camera), "main camera", camera_check_state, CAMERA_CALLBACK_MAX);
camera->portname = P_STR(INDI_MAIN_CAMERA_PORT);
indi_device_add_cb(indi, P_STR(INDI_MAIN_CAMERA_NAME), (IndiDevCB)camera_connect, camera);
g_object_set_data(G_OBJECT(window), "camera-main", camera);
} else {
INDI_common_init(INDI_COMMON (camera), "guide camera", camera_check_state, CAMERA_CALLBACK_MAX);
camera->portname = P_STR(INDI_GUIDE_CAMERA_PORT);
indi_device_add_cb(indi, P_STR(INDI_GUIDE_CAMERA_NAME), (IndiDevCB)camera_connect, camera);
g_object_set_data(G_OBJECT(window), "camera-guide", camera);
}
if (camera->ready)
return camera;
return NULL;
}
int main(void)
{
TASK *task_cb;
/* Initialize scheduler. */
scheduler_init();
/* Initialize memory. */
mem_init();
/* Initialize file system. */
fs_init();
/* Create a task for CDC demo. */
task_cb = (TASK *)mem_static_alloc(sizeof(TASK) + 4096);
task_create(task_cb, P_STR("STATS"), (uint8_t *)(task_cb + 1), 4096, &parser_demo_task, (void *)(NULL), 0);
scheduler_task_add(task_cb, 5);
/* Run scheduler. */
kernel_run();
return (0);
}
struct fwheel_t *fwheel_find(void *window)
{
struct fwheel_t *fwheel;
struct indi_t *indi;
fwheel = (struct fwheel_t *)g_object_get_data(G_OBJECT(window), "fwheel");
if (fwheel) {
if (fwheel->ready) {
d4_printf("Found filter wheel\n");
return fwheel;
}
return NULL;
}
if (! (indi = INDI_get_indi(window)))
return NULL;
fwheel = g_new0(struct fwheel_t, 1);
INDI_common_init(INDI_COMMON (fwheel), "filter wheel", fwheel_check_state, FWHEEL_CALLBACK_MAX);
indi_device_add_cb(indi, P_STR(INDI_FWHEEL_NAME), (IndiDevCB)fwheel_connect, fwheel);
g_object_set_data(G_OBJECT(window), "fwheel", fwheel);
if (fwheel->ready)
return fwheel;
return NULL;
}
int do_psync_account_teams(psync_userid_t teamids[], int nids, result_visitor vis, void *param) {
psync_socket *sock;
binresult *bres;
char *ids = NULL;
char *idsp = 0;
int k,i;
const binresult *users;
if (nids) {
ids = (char *) psync_malloc(nids*FOLDERID_ENTRY_SIZE);
idsp = ids;
for (i = 0; i < nids; ++i) {
k = sprintf(idsp, "%lld", (long long) teamids[i]);
if (unlikely(k <= 0 )) break;
idsp[k] = ',';
idsp = idsp + k + 1;
}
if (i > 0)
*(idsp - 1) = '\0';
//debug(D_NOTICE, "Account_teams numids %d\n", nids);
binparam params[] = {P_STR("auth", psync_my_auth), P_STR("timeformat", "timestamp"), P_STR("teamids", ids), P_STR("showeveryone", "1")};
sock = psync_apipool_get();
bres = send_command(sock, "account_teams", params);
} else {
if (psync_my_auth[0]) {
binparam params[] = {P_STR("auth", psync_my_auth), P_STR("timeformat", "timestamp"), P_STR("showeveryone", "1")};
sock = psync_apipool_get();
bres = send_command(sock, "account_teams", params);
} else if (psync_my_user && psync_my_pass) {
binparam params[] = {P_STR("username", psync_my_user), P_STR("password", psync_my_pass), P_STR("timeformat", "timestamp"), P_STR("showeveryone", "1")};
sock = psync_apipool_get();
bres = send_command(sock, "account_teams", params);
} else return -1;
}
if (likely(bres))
psync_apipool_release(sock);
else {
psync_apipool_release_bad(sock);
debug(D_WARNING, "Send command returned in valid result.\n");
return -1;
}
users = psync_find_result(bres, "teams", PARAM_ARRAY);
//debug(D_NOTICE, "Result contains %d teams\n", users->length);
if (!users->length){
psync_free(bres);
psync_free(ids);
debug(D_WARNING, "Account_teams returned empty result!\n");
return -2;
} else {
for (i = 0; i < users->length; ++i)
vis(i, users->array[i], param);
}
psync_free(bres);
psync_free(ids);
return 0;
}
void RegisterWindow::doRegister(){
if (!ui->accepttos->checkState()){
setError("Registration only possible upon acceptance of terms.");
return;
}
if (ui->password->text().length()<6){
setError("Password too short - minimum 6 characters.");
return;
}
if (ui->password->text()!=ui->confirmpassword->text()){
setError("Password confirmation does not match.");
return;
}
QByteArray email=ui->email->text().toUtf8();
QByteArray password=ui->password->text().toUtf8();
apisock *conn;
binresult *res, *result;
QByteArray err;
quint64 type=0;
#if defined(Q_OS_WIN)
type=5;
#elif defined(Q_OS_LINUX)
type=7;
#elif defined(Q_OS_MAC)
type=6;
#endif
if (!(conn=app->getAPISock())){
setError("Connection to server failed.");
return;
}
res=send_command(conn, "register",
P_STR("termsaccepted", "yes"),
P_LSTR("mail", email.constData(), email.size()),
P_LSTR("password", password.constData(), password.size()),
P_NUM("os", type));
result=find_res(res, "result");
if (!result){
setError("Connection to server failed.");
free(res);
api_close(conn);
return;
}
if (result->num!=0){
setError(find_res(res, "error")->str);
free(res);
api_close(conn);
return;
}
res=send_command(conn, "userinfo",
P_LSTR("username", email.constData(), email.size()),
P_LSTR("password", password.constData(), password.size()),
P_BOOL("getauth", 1));
api_close(conn);
result=find_res(res, "result");
if (!result){
setError("Connection to server failed.");
free(res);
return;
}
if (result->num!=0){
setError(find_res(res, "error")->str);
free(res);
return;
}
if (!app->userLogged(res, err, false))
setError(err);
else{
setError("");
ui->password->clear();
ui->confirmpassword->clear();
hide();
}
free(res);
}
