From 8ad1fe6086e31a082417756aa31a5ad5c4ff6c32 Mon Sep 17 00:00:00 2001 From: Levi Neely <141506390+lneely@users.noreply.github.com> Date: Sun, 9 Mar 2025 09:14:12 +0100 Subject: [PATCH] Code cleanup and readline for better CLI UX (#116) * pcommands.h for command ids * remove compiler compat junk * transient and unnecessary includes resolved * unnecessary goto * function naming and whatnot * use readline for better command line UX * add readline to CI workflow --- .github/workflows/c-cpp.yml | 2 +- Makefile | 2 +- control_tools.cpp | 68 ++++-- pclsync/pcommands.h | 8 + pclsync/pcompiler.h | 112 ---------- pclsync/pcryptofolder.c | 414 ++++++++++++++++-------------------- pclsync/pcryptofolder.h | 10 +- pclsync/pdiff.c | 1 + pclsync/pdownload.c | 2 + pclsync/pdownload.h | 2 +- pclsync/pfolder.c | 1 + pclsync/pfs.h | 2 +- pclsync/pfstasks.h | 2 +- pclsync/pfsupload.c | 1 + pclsync/pfsupload.h | 2 +- pclsync/pfsxattr.h | 5 +- pclsync/plibs.c | 2 + pclsync/plibs.h | 4 +- pclsync/plocalnotify.h | 2 +- pclsync/plocalscan.h | 2 +- pclsync/pnetlibs.c | 8 +- pclsync/pnetlibs.h | 3 +- pclsync/pnotify.c | 2 +- pclsync/ppagecache.c | 1 + pclsync/pssl.h | 18 +- pclsync/pstatus.h | 8 + pclsync/ptask.c | 27 +++ pclsync/ptask.h | 28 ++- pclsync/ptools.c | 1 + pclsync_lib.cpp | 61 +++--- 30 files changed, 380 insertions(+), 421 deletions(-) create mode 100644 pclsync/pcommands.h diff --git a/.github/workflows/c-cpp.yml b/.github/workflows/c-cpp.yml index e96f186..cfce995 100644 --- a/.github/workflows/c-cpp.yml +++ b/.github/workflows/c-cpp.yml @@ -12,6 +12,6 @@ jobs: steps: - uses: actions/checkout@v4 - name: make - run: sudo apt-get update && sudo apt-get install -y libudev-dev libfuse-dev libsqlite3-dev zlib1g-dev libboost-dev libboost-system-dev libboost-program-options-dev libmbedtls-dev + run: sudo apt-get update && sudo apt-get install -y libreadline-dev libudev-dev libfuse-dev libsqlite3-dev zlib1g-dev libboost-dev libboost-system-dev libboost-program-options-dev libmbedtls-dev - name: make run: make diff --git a/Makefile b/Makefile index 54d169c..d625673 100644 --- a/Makefile +++ b/Makefile @@ -7,7 +7,7 @@ ifneq (,$(filter clang%,$(CC))) CFLAGS += -Wthread-safety endif CXXFLAGS = $(CFLAGS) -LIBLDFLAGS = $(COMMONFLAGS) -lpthread -ludev -lsqlite3 -lz -l:libmbedtls.so.14 -l:libmbedx509.so.1 -l:libmbedcrypto.so.7 +LIBLDFLAGS = $(COMMONFLAGS) -lreadline -lpthread -ludev -lsqlite3 -lz -l:libmbedtls.so.14 -l:libmbedx509.so.1 -l:libmbedcrypto.so.7 EXECLDFLAGS = $(COMMONFLAGS) -lboost_program_options -lfuse SCAN := 0 diff --git a/control_tools.cpp b/control_tools.cpp index 4113afd..6068f70 100644 --- a/control_tools.cpp +++ b/control_tools.cpp @@ -36,6 +36,8 @@ #include #include #include +#include +#include #include "control_tools.h" @@ -43,6 +45,7 @@ #include "pclsync/pshm.h" #include "pclsync/pfoldersync.h" #include "pclsync/rpcclient.h" +#include "pclsync/pcommands.h" #include "CLI11.hpp" @@ -52,15 +55,6 @@ namespace control_tools { static const int STOP = 0; -enum command_ids_ { - STARTCRYPTO = 20, - STOPCRYPTO, - FINALIZE, - LISTSYNC, - ADDSYNC, - STOPSYNC -}; - int list_sync_folders() { int ret; char *errm; @@ -235,7 +229,7 @@ int finalize() { return ret; } -void help() { +static void help() { std::cout << "Supported commands are:" << std::endl << " help(?): Show this help message" << std::endl << " crypto(c):" << std::endl @@ -249,6 +243,45 @@ void help() { << " quit(q): Exit this program" << std::endl; } +static char* command_generator(const char* text, int state) { + static int list_index, len; + static const char* commands[] = { + "help", "?", + "crypto", "crypto start", "crypto stop", + "c", "c start", "c stop", + "sync", "sync ls", "sync add", "sync remove", "sync rm", + "s", "s ls", "s add", "s remove", "s rm", + "finalize", "f", + "quit", "q", + nullptr + }; + + // If this is a new word to complete, initialize + if (!state) { + list_index = 0; + len = strlen(text); + } + + // Return the next name which partially matches + while (const char* command = commands[list_index++]) { + if (strncmp(command, text, len) == 0) { + return strdup(command); // Caller frees this with free() + } + } + + return nullptr; // No more matches +} + +static char** command_completion(const char* text, int start, int end) { + // If this is the start of line, complete commands + if (start == 0) { + return rl_completion_matches(text, command_generator); + } + + // Otherwise, don't complete + return nullptr; +} + void process_commands() { CLI::App app{"pcloudcc-lneely"}; app.fallthrough(); @@ -298,12 +331,19 @@ void process_commands() { sync_remove_cmd->add_option("folderid", syncrm_fid, "Folder ID")->required(); sync_remove_cmd->callback([&] { remove_sync_folder(syncrm_fid.c_str()); }); + using_history(); + // command loop + rl_attempted_completion_function = command_completion; while (true) { - std::cout << "pcloud> "; - std::string line; - if (!std::getline(std::cin, line)) - break; + char* line_read = readline("pcloud> "); + if (!line_read) break; + if (line_read[0]) { + add_history(line_read); + } + std::string line(line_read); + free(line_read); + try { app.parse(line); } catch (const CLI::ParseError &e) { diff --git a/pclsync/pcommands.h b/pclsync/pcommands.h new file mode 100644 index 0000000..9fca4c1 --- /dev/null +++ b/pclsync/pcommands.h @@ -0,0 +1,8 @@ +enum command_ids_ { + STARTCRYPTO = 20, + STOPCRYPTO, + FINALIZE, + LISTSYNC, + ADDSYNC, + STOPSYNC +}; diff --git a/pclsync/pcompiler.h b/pclsync/pcompiler.h index 140a7e5..ad3d356 100644 --- a/pclsync/pcompiler.h +++ b/pclsync/pcompiler.h @@ -32,132 +32,20 @@ #ifndef _PSYNC_COMPILER_H #define _PSYNC_COMPILER_H -#if defined(_MSC_VER) -#include -#endif - -#if !defined(__has_attribute) -#if defined(__GNUC__) -#define __has_attribute(x) 1 -#else -#define __has_attribute(x) 0 -#endif -#else -#if defined(__GNUC__) && !__has_attribute(malloc) -#undef __has_attribute -#define __has_attribute(x) 1 -#endif -#endif - -#ifndef __has_builtin -#if defined(__GNUC__) -#define __has_builtin(x) 1 -#else -#define __has_builtin(x) 0 -#endif -#endif - -#if __has_builtin(__builtin_expect) #define likely(expr) __builtin_expect(!!(expr), 1) #define unlikely(expr) __builtin_expect(!!(expr), 0) -#else -#define likely(expr) (expr) -#define unlikely(expr) (expr) -#endif - -#if __has_builtin(__builtin_prefetch) #define psync_prefetch(expr) __builtin_prefetch(expr) -#elif defined(_MSC_VER) -#define psync_prefetch(expr) _mm_prefetch((char *)(expr), _MM_HINT_T0) -#else -#define psync_prefetch(expr) ((void)0) -#endif - -#if defined(_MSC_VER) -#define PSYNC_THREAD __declspec(thread) -#define PSYNC_NOINLINE __declspec(noinline) -#else -#if __has_attribute(noinline) #define PSYNC_NOINLINE __attribute__((noinline)) -#else -#define PSYNC_NOINLINE -#endif #define PSYNC_THREAD __thread -#endif -#if __has_attribute(malloc) #define PSYNC_MALLOC __attribute__((malloc)) -#else -#define PSYNC_MALLOC -#endif - -#if __has_attribute(sentinel) #define PSYNC_SENTINEL __attribute__((sentinel)) -#else -#define PSYNC_SENTINEL -#endif - -#if __has_attribute(pure) #define PSYNC_PURE __attribute__((pure)) -#else -#define PSYNC_PURE -#endif - -#if __has_attribute(const) #define PSYNC_CONST __attribute__((const)) -#else -#define PSYNC_CONST -#endif - -#if __has_attribute(cold) #define PSYNC_COLD __attribute__((cold)) -#else -#define PSYNC_COLD -#endif - -#if __has_attribute(format) #define PSYNC_FORMAT(a, b, c) __attribute__((format(a, b, c))) -#else -#define PSYNC_FORMAT(a, b, c) -#endif - -#if __has_attribute(nonnull) #define PSYNC_NONNULL(...) __attribute__((nonnull(__VA_ARGS__))) -#else -#define PSYNC_NONNULL(...) -#endif - -#if __has_attribute(packed) #define PSYNC_PACKED_STRUCT struct __attribute__((packed)) -#elif defined(_MSC_VER) -#define PSYNC_PACKED_STRUCT __declspec(align(1)) struct -#else -#define PSYNC_PACKED_STRUCT struct -#endif - -#if _MSC_VER >= 1500 && _MSC_VER < 1600 -#define inline __inline -#define restrict __restrict -#elif __GNUC__ >= 3 -#define inline __inline -#define restrict __restrict -#elif __STDC_VERSION__ != 199901L -#define inline -#define restrict -#endif - -#if defined(__clang__) || defined(_MSC_VER) -#define psync_alignof __alignof -#elif defined(__GNUC__) #define psync_alignof __alignof__ -#else -#define psync_alignof(t) \ - offsetof( \ - struct { \ - char a; \ - t b; \ - }, \ - b) -#endif #endif diff --git a/pclsync/pcryptofolder.c b/pclsync/pcryptofolder.c index efaaeda..02f6980 100644 --- a/pclsync/pcryptofolder.c +++ b/pclsync/pcryptofolder.c @@ -52,6 +52,7 @@ #include "pssl.h" #include "prun.h" #include "psys.h" +#include "ptask.h" #include @@ -94,22 +95,22 @@ typedef struct { unsigned char hmackey[PSYNC_CRYPTO_HMAC_SHA512_KEY_LEN]; } sym_key_ver1; -void sha1_hex_null_term(const void *data, size_t len, char *out); +static void sha1hex(const void *data, size_t len, char *out); void pcryptofolder_cache_clean() { const char *prefixes[] = {"DKEY", "FKEY", "FLDE", "FLDD", "SEEN"}; pcache_clean_oneof(prefixes, ARRAY_SIZE(prefixes)); } -static inline int psync_crypto_is_error(const void *ptr) { +static inline int is_err(const void *ptr) { return (uintptr_t)ptr <= PSYNC_CRYPTO_MAX_ERROR; } -static inline int psync_crypto_to_error(const void *ptr) { +static inline int to_err(const void *ptr) { return -((int)(uintptr_t)ptr); } -static void psync_cloud_crypto_setup_save_to_db( +static void save_to_db( const unsigned char *rsapriv, size_t rsaprivlen, const unsigned char *rsapub, size_t rsapublen, const unsigned char *salt, size_t saltlen, size_t iterations, time_t expires, const char *publicsha1, @@ -150,7 +151,7 @@ static void psync_cloud_crypto_setup_save_to_db( psync_sql_commit_transaction(); } -static int psync_cloud_crypto_setup_do_upload(const unsigned char *rsapriv, +static int setup_do_upload(const unsigned char *rsapriv, size_t rsaprivlen, const unsigned char *rsapub, size_t rsapublen, @@ -210,7 +211,7 @@ static void load_str_to(const psync_variant *v, unsigned char **ptr, *len = l; } -static int psync_cloud_crypto_download_keys( +static int download_keys( unsigned char **rsapriv, size_t *rsaprivlen, unsigned char **rsapub, size_t *rsapublen, unsigned char **salt, size_t *saltlen, size_t *iterations, char *publicsha1, char *privatesha1, uint32_t *flags) { @@ -259,8 +260,8 @@ static int psync_cloud_crypto_download_keys( rsapubstruct = psync_base64_decode((const unsigned char *)data->str, data->length, &rsapubstructlen); psync_free(res); - sha1_hex_null_term(rsaprivstruct, rsaprivstructlen, privatesha1); - sha1_hex_null_term(rsapubstruct, rsapubstructlen, publicsha1); + sha1hex(rsaprivstruct, rsaprivstructlen, privatesha1); + sha1hex(rsapubstruct, rsapubstructlen, publicsha1); debug(D_NOTICE, "rsapubstruct=%s", rsapubstruct); switch (*((uint32_t *)rsapubstruct)) { case PSYNC_CRYPTO_PUB_TYPE_RSA4096: @@ -319,7 +320,7 @@ static binresult *psync_get_keys_bin_auth(const char *auth) { } static int -psync_cloud_crypto_setup_upload(const unsigned char *rsapriv, size_t rsaprivlen, +setup_upload(const unsigned char *rsapriv, size_t rsaprivlen, const unsigned char *rsapub, size_t rsapublen, const unsigned char *salt, const char *hint, time_t *cryptoexpires, char *publicsha1, @@ -340,9 +341,9 @@ psync_cloud_crypto_setup_upload(const unsigned char *rsapriv, size_t rsaprivlen, pub->type = PSYNC_CRYPTO_PUB_TYPE_RSA4096; pub->flags = 0; memcpy(pub->key, rsapub, rsapublen); - sha1_hex_null_term(priv, offsetof(priv_key_ver1, key) + rsaprivlen, + sha1hex(priv, offsetof(priv_key_ver1, key) + rsaprivlen, privatesha1); - sha1_hex_null_term(pub, offsetof(pub_key_ver1, key) + rsapublen, publicsha1); + sha1hex(pub, offsetof(pub_key_ver1, key) + rsapublen, publicsha1); b64priv = psync_base64_encode((unsigned char *)priv, offsetof(priv_key_ver1, key) + rsaprivlen, &b64privlen); @@ -351,7 +352,7 @@ psync_cloud_crypto_setup_upload(const unsigned char *rsapriv, size_t rsaprivlen, offsetof(pub_key_ver1, key) + rsapublen, &b64publen); psync_free(priv); psync_free(pub); - ret = psync_cloud_crypto_setup_do_upload(b64priv, b64privlen, b64pub, + ret = setup_do_upload(b64priv, b64privlen, b64pub, b64publen, hint, cryptoexpires); psync_free(b64priv); psync_free(b64pub); @@ -432,7 +433,7 @@ int pcryptofolder_setup(const char *password, const char *hint) { rsaprivatebin->datalen, 0); pcrypto_ctr_encdec_free(enc); debug(D_NOTICE, "encoded private key, uploading keys"); - ret = psync_cloud_crypto_setup_upload( + ret = setup_upload( rsaprivatebin->data, rsaprivatebin->datalen, rsapublicbin->data, rsapublicbin->datalen, salt, hint, &cryptoexpires, publicsha1, privatesha1); @@ -443,7 +444,7 @@ int pcryptofolder_setup(const char *password, const char *hint) { return ret; } debug(D_NOTICE, "keys uploaded"); - psync_cloud_crypto_setup_save_to_db( + save_to_db( rsaprivatebin->data, rsaprivatebin->datalen, rsapublicbin->data, rsapublicbin->datalen, salt, PSYNC_CRYPTO_PBKDF2_SALT_LEN, PSYNC_CRYPTO_PASS_TO_KEY_ITERATIONS, cryptoexpires, publicsha1, @@ -548,21 +549,22 @@ int pcryptofolder_unlock(const char *password) { * to have some thread to hold sql_lock and wait for read lock. This will * normally deadlock with us holding writelock and waiting for sql_lock. * Therefore we use sql_trylock here. - * */ -retry: - pthread_rwlock_wrlock(&crypto_lock); - if (crypto_started_l) { - pthread_rwlock_unlock(&crypto_lock); - return PRINT_RETURN_CONST(PSYNC_CRYPTO_START_ALREADY_STARTED); - } - rowcnt = 0; - rsapriv = rsapub = salt = NULL; - iterations = 0; - if (psync_sql_trylock()) { - pthread_rwlock_unlock(&crypto_lock); - psys_sleep_milliseconds(1); - goto retry; + while (1) { + pthread_rwlock_wrlock(&crypto_lock); + if (crypto_started_l) { + pthread_rwlock_unlock(&crypto_lock); + return PRINT_RETURN_CONST(PSYNC_CRYPTO_START_ALREADY_STARTED); + } + rowcnt = 0; + rsapriv = rsapub = salt = NULL; + iterations = 0; + if (psync_sql_trylock()) { + pthread_rwlock_unlock(&crypto_lock); + psys_sleep_milliseconds(1); + continue; + } + break; } res = psync_sql_query_nolock( "SELECT id, value FROM setting WHERE id IN ('crypto_private_key', " @@ -591,7 +593,7 @@ retry: psync_free(rsapub); psync_free(salt); } - ret = psync_cloud_crypto_download_keys( + ret = download_keys( &rsapriv, &rsaprivlen, &rsapub, &rsapublen, &salt, &saltlen, &iterations, publicsha1, privatesha1, &flags); if (ret != PSYNC_CRYPTO_START_SUCCESS) { @@ -604,6 +606,8 @@ retry: debug(D_NOTICE, "got keys from the database"); assert(rowcnt == 4); } + + debug(D_NOTICE, "trying to load public key"); crypto_pubkey = psync_ssl_rsa_load_public(rsapub, rsapublen); if (crypto_pubkey == PSYNC_INVALID_RSA) { pthread_rwlock_unlock(&crypto_lock); @@ -613,6 +617,10 @@ retry: psync_free(salt); return PRINT_RETURN_CONST(PSYNC_CRYPTO_START_UNKNOWN_KEY_FORMAT); } + debug(D_NOTICE, "successfully loaded public key"); + + + debug(D_NOTICE, "generating symmetric key"); aeskey = psync_ssl_gen_symmetric_key_from_pass( password, PSYNC_AES256_KEY_SIZE + PSYNC_AES256_BLOCK_SIZE, salt, saltlen, iterations); @@ -622,19 +630,26 @@ retry: memcpy(rsaprivdec, rsapriv, rsaprivlen); pcrypto_ctr_encdec_decode(enc, rsaprivdec, rsaprivlen, 0); pcrypto_ctr_encdec_free(enc); + debug(D_NOTICE, "successfully generated symmetric key"); + + + debug(D_NOTICE, "trying to load private key"); crypto_privkey = psync_ssl_rsa_load_private(rsaprivdec, rsaprivlen); psync_ssl_memclean(rsaprivdec, rsaprivlen); pmemlock_free(rsaprivdec); if (crypto_privkey == PSYNC_INVALID_RSA) { + debug(D_NOTICE, "failed to load private key"); psync_ssl_rsa_free_public(crypto_pubkey); crypto_pubkey = PSYNC_INVALID_RSA; pthread_rwlock_unlock(&crypto_lock); - debug(D_NOTICE, "bad password"); psync_free(rsapriv); psync_free(rsapub); psync_free(salt); return PRINT_RETURN_CONST(PSYNC_CRYPTO_START_BAD_PASSWORD); } + debug(D_NOTICE, "successfully loaded private key"); + + debug(D_NOTICE, "verify matching public and private key"); if (!crypto_keys_match()) { psync_ssl_rsa_free_public(crypto_pubkey); crypto_pubkey = PSYNC_INVALID_RSA; @@ -647,13 +662,17 @@ retry: psync_free(salt); return PRINT_RETURN_CONST(PSYNC_CRYPTO_START_KEYS_DONT_MATCH); } + debug(D_NOTICE, "public and private keys match, setting crypto started"); + crypto_started_l = 1; crypto_started_un = 1; pthread_rwlock_unlock(&crypto_lock); - if (rowcnt < 4) - psync_cloud_crypto_setup_save_to_db(rsapriv, rsaprivlen, rsapub, rsapublen, + if (rowcnt < 4) { + debug(D_NOTICE, "saving crypto setup to database"); + save_to_db(rsapriv, rsaprivlen, rsapub, rsapublen, salt, saltlen, iterations, 0, publicsha1, privatesha1, flags); + } psync_free(rsapriv); psync_free(rsapub); psync_free(salt); @@ -740,7 +759,16 @@ int pcryptofolder_reset() { } } -static void *err_to_ptr(int err) { return (void *)(uintptr_t)(-err); } +static void sha1hex(const void *data, size_t len, char *out) { + unsigned char sha1bin[PSYNC_SHA1_DIGEST_LEN + 1]; + psync_sha1((const unsigned char *)data, len, (unsigned char *)sha1bin); + psync_binhex(out, sha1bin, PSYNC_SHA1_DIGEST_LEN); + out[PSYNC_SHA1_DIGEST_HEXLEN] = 0; // add null terminator +} + +static void *errptr(int err) { + return (void *)(uintptr_t)(-err); +} static void set_crypto_err_msg(const binresult *res) { const binresult *msg; @@ -752,25 +780,7 @@ static void set_crypto_err_msg(const binresult *res) { memcpy(crypto_api_err, msg->str, l); } -typedef struct { - psync_encrypted_symmetric_key_t key; - psync_folderid_t id; -} insert_folder_key_task; - -static void save_folder_key_task(void *ptr) { - insert_folder_key_task *t; - psync_sql_res *res; - t = (insert_folder_key_task *)ptr; - res = psync_sql_prep_statement( - "REPLACE INTO cryptofolderkey (folderid, enckey) VALUES (?, ?)"); - psync_sql_bind_uint(res, 1, t->id); - psync_sql_bind_blob(res, 2, (const char *)t->key->data, t->key->datalen); - psync_sql_run_free(res); - psync_free(t->key); - psync_free(t); -} - -static void save_folder_key_to_db(psync_folderid_t folderid, +static void save_folder_key(psync_folderid_t folderid, psync_encrypted_symmetric_key_t enckey) { // we are likely holding (few) read locks on the database, so executing here // will deadlock @@ -778,27 +788,7 @@ static void save_folder_key_to_db(psync_folderid_t folderid, t = psync_new(insert_folder_key_task); t->key = psync_ssl_copy_encrypted_symmetric_key(enckey); t->id = folderid; - prun_thread1("save folder key to db task", save_folder_key_task, t); -} - -typedef struct { - psync_encrypted_symmetric_key_t key; - psync_fileid_t id; - uint64_t hash; -} insert_file_key_task; - -static void save_file_key_task(void *ptr) { - insert_file_key_task *t; - psync_sql_res *res; - t = (insert_file_key_task *)ptr; - res = psync_sql_prep_statement( - "REPLACE INTO cryptofilekey (fileid, hash, enckey) VALUES (?, ?, ?)"); - psync_sql_bind_uint(res, 1, t->id); - psync_sql_bind_uint(res, 2, t->hash); - psync_sql_bind_blob(res, 3, (const char *)t->key->data, t->key->datalen); - psync_sql_run_free(res); - psync_free(t->key); - psync_free(t); + prun_thread1("save folder key to db task", ptask_cfldr_save_fldrkey, t); } static void save_file_key_to_db(psync_fileid_t fileid, uint64_t hash, @@ -808,11 +798,10 @@ static void save_file_key_to_db(psync_fileid_t fileid, uint64_t hash, t->key = psync_ssl_copy_encrypted_symmetric_key(enckey); t->id = fileid; t->hash = hash; - prun_thread1("save file key to db task", save_file_key_task, t); + prun_thread1("save file key to db task", ptask_cfldr_save_filekey, t); } -static psync_encrypted_symmetric_key_t -psync_crypto_download_folder_enc_key(psync_folderid_t folderid) { +static psync_encrypted_symmetric_key_t download_fldr_enckey(psync_folderid_t folderid) { binparam params[] = {PAPI_STR("auth", psync_my_auth), PAPI_NUM("folderid", folderid)}; psock_t *api; @@ -828,13 +817,13 @@ psync_crypto_download_folder_enc_key(psync_folderid_t folderid) { while (1) { api = psync_apipool_get(); if (!api) - return (psync_encrypted_symmetric_key_t)err_to_ptr( + return (psync_encrypted_symmetric_key_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_CANT_CONNECT)); res = papi_send2(api, "crypto_getfolderkey", params); if (unlikely_log(!res)) { psync_apipool_release_bad(api); if (++tries > 5) - return (psync_encrypted_symmetric_key_t)err_to_ptr( + return (psync_encrypted_symmetric_key_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_CANT_CONNECT)); } else { psync_apipool_release(api); @@ -849,7 +838,7 @@ psync_crypto_download_folder_enc_key(psync_folderid_t folderid) { set_crypto_err_msg(res); psync_free(res); psync_process_api_error(result); - return (psync_encrypted_symmetric_key_t)err_to_ptr( + return (psync_encrypted_symmetric_key_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_API_ERR_INTERNAL)); } b64key = papi_find_result2(res, "key", PARAM_STR); @@ -857,17 +846,16 @@ psync_crypto_download_folder_enc_key(psync_folderid_t folderid) { &keylen); psync_free(res); if (!key) - return (psync_encrypted_symmetric_key_t)err_to_ptr( + return (psync_encrypted_symmetric_key_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY)); ret = psync_ssl_alloc_encrypted_symmetric_key(keylen); memcpy(ret->data, key, keylen); psync_free(key); - save_folder_key_to_db(folderid, ret); + save_folder_key(folderid, ret); return ret; } -static psync_encrypted_symmetric_key_t -psync_crypto_download_file_enc_key(psync_fileid_t fileid) { +static psync_encrypted_symmetric_key_t download_file_enckey(psync_fileid_t fileid) { binparam params[] = {PAPI_STR("auth", psync_my_auth), PAPI_NUM("fileid", fileid)}; psock_t *api; binresult *res; @@ -882,13 +870,13 @@ psync_crypto_download_file_enc_key(psync_fileid_t fileid) { while (1) { api = psync_apipool_get(); if (!api) - return (psync_encrypted_symmetric_key_t)err_to_ptr( + return (psync_encrypted_symmetric_key_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_CANT_CONNECT)); res = papi_send2(api, "crypto_getfilekey", params); if (unlikely_log(!res)) { psync_apipool_release_bad(api); if (++tries > 5) - return (psync_encrypted_symmetric_key_t)err_to_ptr( + return (psync_encrypted_symmetric_key_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_CANT_CONNECT)); } else { psync_apipool_release(api); @@ -902,7 +890,7 @@ psync_crypto_download_file_enc_key(psync_fileid_t fileid) { crypto_api_errno = result; set_crypto_err_msg(res); psync_free(res); - return (psync_encrypted_symmetric_key_t)err_to_ptr( + return (psync_encrypted_symmetric_key_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_API_ERR_INTERNAL)); } result = papi_find_result2(res, "hash", PARAM_NUM)->num; @@ -911,7 +899,7 @@ psync_crypto_download_file_enc_key(psync_fileid_t fileid) { &keylen); psync_free(res); if (!key) - return (psync_encrypted_symmetric_key_t)err_to_ptr( + return (psync_encrypted_symmetric_key_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY)); ret = psync_ssl_alloc_encrypted_symmetric_key(keylen); memcpy(ret->data, key, keylen); @@ -920,8 +908,7 @@ psync_crypto_download_file_enc_key(psync_fileid_t fileid) { return ret; } -static psync_encrypted_symmetric_key_t -psync_crypto_get_folder_enc_key(psync_folderid_t folderid) { +static psync_encrypted_symmetric_key_t get_fldr_enckey(psync_folderid_t folderid) { psync_encrypted_symmetric_key_t enckey; psync_sql_res *res; psync_variant_row row; @@ -938,11 +925,10 @@ psync_crypto_get_folder_enc_key(psync_folderid_t folderid) { return enckey; } psync_sql_free_result(res); - return psync_crypto_download_folder_enc_key(folderid); + return download_fldr_enckey(folderid); } -static psync_encrypted_symmetric_key_t -psync_crypto_get_file_enc_key(psync_fileid_t fileid, uint64_t hash, +static psync_encrypted_symmetric_key_t get_file_enckey(psync_fileid_t fileid, uint64_t hash, int nonetwork) { psync_encrypted_symmetric_key_t enckey; psync_sql_res *res; @@ -967,11 +953,10 @@ psync_crypto_get_file_enc_key(psync_fileid_t fileid, uint64_t hash, return ( psync_encrypted_symmetric_key_t)PSYNC_CRYPTO_UNLOADED_SECTOR_ENCODER; } else - return psync_crypto_download_file_enc_key(fileid); + return download_file_enckey(fileid); } -static psync_symmetric_key_t -psync_crypto_get_folder_symkey_locked(psync_folderid_t folderid) { +static psync_symmetric_key_t get_fldr_symkey_safe(psync_folderid_t folderid) { char buff[16]; psync_encrypted_symmetric_key_t enckey; psync_symmetric_key_t symkey; @@ -979,21 +964,20 @@ psync_crypto_get_folder_symkey_locked(psync_folderid_t folderid) { symkey = (psync_symmetric_key_t)pcache_get(buff); if (symkey) return symkey; - enckey = psync_crypto_get_folder_enc_key(folderid); - if (psync_crypto_is_error(enckey)) + enckey = get_fldr_enckey(folderid); + if (is_err(enckey)) return (psync_symmetric_key_t)enckey; symkey = psync_ssl_rsa_decrypt_symm_key_lock(&crypto_privkey, &enckey); psync_free(enckey); if (symkey == PSYNC_INVALID_SYM_KEY) - return (psync_symmetric_key_t)err_to_ptr( + return (psync_symmetric_key_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY)); return symkey; } -static psync_symmetric_key_t -psync_crypto_get_file_symkey_locked(psync_fileid_t fileid, uint64_t hash, +static psync_symmetric_key_t get_file_symkey_safe(psync_fileid_t fileid, uint64_t hash, int nonetwork) { char buff[32]; psync_encrypted_symmetric_key_t enckey; @@ -1004,8 +988,8 @@ psync_crypto_get_file_symkey_locked(psync_fileid_t fileid, uint64_t hash, debug(D_NOTICE, "got key for file %lu from cache", (unsigned long)fileid); return symkey; } - enckey = psync_crypto_get_file_enc_key(fileid, hash, nonetwork); - if (unlikely_log(psync_crypto_is_error(enckey))) + enckey = get_file_enckey(fileid, hash, nonetwork); + if (unlikely_log(is_err(enckey))) return (psync_symmetric_key_t)enckey; if (nonetwork && enckey == @@ -1016,12 +1000,12 @@ psync_crypto_get_file_symkey_locked(psync_fileid_t fileid, uint64_t hash, psync_free(enckey); if (unlikely_log(symkey == PSYNC_INVALID_SYM_KEY)) - return (psync_symmetric_key_t)err_to_ptr( + return (psync_symmetric_key_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY)); return symkey; } -static void psync_crypto_release_symkey_ptr(void *ptr) { +static void free_symkey(void *ptr) { psync_ssl_free_symmetric_key((psync_symmetric_key_t)ptr); } @@ -1031,7 +1015,7 @@ psync_crypto_release_folder_symkey_locked(psync_folderid_t folderid, char buff[16]; psync_get_string_id(buff, "FKEY", folderid); pcache_add(buff, key, PSYNC_CRYPTO_CACHE_DIR_SYM_KEY, - psync_crypto_release_symkey_ptr, 2); + free_symkey, 2); } static void psync_crypto_release_file_symkey_locked(psync_fileid_t fileid, @@ -1040,11 +1024,10 @@ static void psync_crypto_release_file_symkey_locked(psync_fileid_t fileid, char buff[32]; psync_get_string_id2(buff, "DKEY", fileid, hash); pcache_add(buff, key, PSYNC_CRYPTO_CACHE_FILE_SYM_KEY, - psync_crypto_release_symkey_ptr, 2); + free_symkey, 2); } -static psync_symmetric_key_t -psync_crypto_sym_key_ver1_to_sym_key(sym_key_ver1 *v1) { +static psync_symmetric_key_t symkeyv1_to_symkey(sym_key_ver1 *v1) { psync_symmetric_key_t key; key = (psync_symmetric_key_t)pmemlock_malloc( offsetof(psync_symmetric_key_struct_t, key) + PSYNC_AES256_KEY_SIZE + @@ -1056,13 +1039,12 @@ psync_crypto_sym_key_ver1_to_sym_key(sym_key_ver1 *v1) { return key; } -static pcrypto_textenc_t -psync_crypto_get_folder_encoder_locked(psync_folderid_t folderid) { +static pcrypto_textenc_t get_fldr_encoder(psync_folderid_t folderid) { pcrypto_textenc_t enc; psync_symmetric_key_t symkey, realkey; sym_key_ver1 *skv1; - symkey = psync_crypto_get_folder_symkey_locked(folderid); - if (psync_crypto_is_error(symkey)) + symkey = get_fldr_symkey_safe(folderid); + if (is_err(symkey)) return (pcrypto_textenc_t)symkey; skv1 = (sym_key_ver1 *)symkey->key; switch (skv1->type) { @@ -1078,7 +1060,7 @@ psync_crypto_get_folder_encoder_locked(psync_folderid_t folderid) { (unsigned long)folderid); goto def1; } - realkey = psync_crypto_sym_key_ver1_to_sym_key(skv1); + realkey = symkeyv1_to_symkey(skv1); psync_crypto_release_folder_symkey_locked(folderid, symkey); enc = pcrypto_textenc_create(realkey); psync_ssl_free_symmetric_key(realkey); @@ -1087,13 +1069,12 @@ psync_crypto_get_folder_encoder_locked(psync_folderid_t folderid) { debug(D_WARNING, "unkown key type %u", (unsigned)skv1->type); def1: psync_ssl_free_symmetric_key(symkey); - return (pcrypto_textenc_t)err_to_ptr( + return (pcrypto_textenc_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY)); } } -static pcrypto_textenc_t -psync_crypto_get_folder_encoder_check_cache_locked(psync_folderid_t folderid) { +static pcrypto_textenc_t get_fldr_encoder_cache(psync_folderid_t folderid) { char buff[16]; pcrypto_textenc_t enc; psync_get_string_id(buff, "FLDE", folderid); @@ -1101,16 +1082,15 @@ psync_crypto_get_folder_encoder_check_cache_locked(psync_folderid_t folderid) { if (enc) return enc; else - return psync_crypto_get_folder_encoder_locked(folderid); + return get_fldr_encoder(folderid); } -static pcrypto_textdec_t -psync_crypto_get_folder_decoder_locked(psync_folderid_t folderid) { +static pcrypto_textdec_t get_fldrdecoder_safe(psync_folderid_t folderid) { pcrypto_textdec_t dec; psync_symmetric_key_t symkey, realkey; sym_key_ver1 *skv1; - symkey = psync_crypto_get_folder_symkey_locked(folderid); - if (psync_crypto_is_error(symkey)) + symkey = get_fldr_symkey_safe(folderid); + if (is_err(symkey)) return (pcrypto_textenc_t)symkey; skv1 = (sym_key_ver1 *)symkey->key; switch (skv1->type) { @@ -1120,7 +1100,7 @@ psync_crypto_get_folder_decoder_locked(psync_folderid_t folderid) { (unsigned long)sizeof(sym_key_ver1), (unsigned long)symkey->keylen); goto def1; } - realkey = psync_crypto_sym_key_ver1_to_sym_key(skv1); + realkey = symkeyv1_to_symkey(skv1); psync_crypto_release_folder_symkey_locked(folderid, symkey); dec = pcrypto_textdec_create(realkey); psync_ssl_free_symmetric_key(realkey); @@ -1129,13 +1109,12 @@ psync_crypto_get_folder_decoder_locked(psync_folderid_t folderid) { debug(D_WARNING, "unkown key type %u", (unsigned)skv1->type); def1: psync_ssl_free_symmetric_key(symkey); - return (pcrypto_textdec_t)err_to_ptr( + return (pcrypto_textdec_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY)); } } -static pcrypto_textenc_t -psync_crypto_get_temp_folder_encoder_locked(psync_fsfolderid_t folderid) { +static pcrypto_textenc_t get_tmp_fldrencoder_safe(psync_fsfolderid_t folderid) { pcrypto_textenc_t enc; psync_symmetric_key_t symkey, realkey; sym_key_ver1 *skv1; @@ -1150,7 +1129,7 @@ psync_crypto_get_temp_folder_encoder_locked(psync_fsfolderid_t folderid) { ; if (psync_is_null(row[0])) { psync_sql_free_result(res); - return (pcrypto_textenc_t)err_to_ptr( + return (pcrypto_textenc_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_FOLDER_NOT_ENCRYPTED)); } b64enckey = (const unsigned char *)psync_get_lstring(row[0], &b64enckeylen); @@ -1163,11 +1142,11 @@ psync_crypto_get_temp_folder_encoder_locked(psync_fsfolderid_t folderid) { symkey = PSYNC_INVALID_SYM_KEY; } else { psync_sql_free_result(res); - return (pcrypto_textenc_t)err_to_ptr( + return (pcrypto_textenc_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_FOLDER_NOT_FOUND)); } if (symkey == PSYNC_INVALID_SYM_KEY) - return (pcrypto_textenc_t)err_to_ptr( + return (pcrypto_textenc_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY)); skv1 = (sym_key_ver1 *)symkey->key; switch (skv1->type) { @@ -1177,7 +1156,7 @@ psync_crypto_get_temp_folder_encoder_locked(psync_fsfolderid_t folderid) { (unsigned long)sizeof(sym_key_ver1), (unsigned long)symkey->keylen); goto def1; } - realkey = psync_crypto_sym_key_ver1_to_sym_key(skv1); + realkey = symkeyv1_to_symkey(skv1); psync_ssl_free_symmetric_key(symkey); enc = pcrypto_textenc_create(realkey); psync_ssl_free_symmetric_key(realkey); @@ -1186,13 +1165,12 @@ psync_crypto_get_temp_folder_encoder_locked(psync_fsfolderid_t folderid) { debug(D_WARNING, "unkown key type %u", (unsigned)skv1->type); def1: psync_ssl_free_symmetric_key(symkey); - return (pcrypto_textenc_t)err_to_ptr( + return (pcrypto_textenc_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY)); } } -static pcrypto_textdec_t -psync_crypto_get_temp_folder_decoder_locked(psync_fsfolderid_t folderid) { +static pcrypto_textdec_t get_tmp_fldrdecoder_safe(psync_fsfolderid_t folderid) { pcrypto_textdec_t dec; psync_symmetric_key_t symkey, realkey; sym_key_ver1 *skv1; @@ -1207,7 +1185,7 @@ psync_crypto_get_temp_folder_decoder_locked(psync_fsfolderid_t folderid) { ; if (psync_is_null(row[0])) { psync_sql_free_result(res); - return (pcrypto_textdec_t)err_to_ptr( + return (pcrypto_textdec_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_FOLDER_NOT_ENCRYPTED)); } b64enckey = (const unsigned char *)psync_get_lstring(row[0], &b64enckeylen); @@ -1225,11 +1203,11 @@ psync_crypto_get_temp_folder_decoder_locked(psync_fsfolderid_t folderid) { } } else { psync_sql_free_result(res); - return (pcrypto_textdec_t)err_to_ptr( + return (pcrypto_textdec_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_FOLDER_NOT_FOUND)); } if (symkey == PSYNC_INVALID_SYM_KEY) - return (pcrypto_textdec_t)err_to_ptr( + return (pcrypto_textdec_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY)); skv1 = (sym_key_ver1 *)symkey->key; switch (skv1->type) { @@ -1239,7 +1217,7 @@ psync_crypto_get_temp_folder_decoder_locked(psync_fsfolderid_t folderid) { (unsigned long)sizeof(sym_key_ver1), (unsigned long)symkey->keylen); goto def1; } - realkey = psync_crypto_sym_key_ver1_to_sym_key(skv1); + realkey = symkeyv1_to_symkey(skv1); psync_ssl_free_symmetric_key(symkey); dec = pcrypto_textdec_create(realkey); psync_ssl_free_symmetric_key(realkey); @@ -1248,17 +1226,16 @@ psync_crypto_get_temp_folder_decoder_locked(psync_fsfolderid_t folderid) { debug(D_WARNING, "unkown key type %u", (unsigned)skv1->type); def1: psync_ssl_free_symmetric_key(symkey); - return (pcrypto_textdec_t)err_to_ptr( + return (pcrypto_textdec_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY)); } } -pcrypto_textdec_t -pcryptofolder_flddecoder_get(psync_fsfolderid_t folderid) { +pcrypto_textdec_t pcryptofolder_flddecoder_get(psync_fsfolderid_t folderid) { char buff[16]; pcrypto_textdec_t dec; if (!crypto_started_un) - return (pcrypto_textdec_t)err_to_ptr( + return (pcrypto_textdec_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_NOT_STARTED)); if (folderid >= 0) { psync_get_string_id(buff, "FLDD", folderid); @@ -1268,14 +1245,14 @@ pcryptofolder_flddecoder_get(psync_fsfolderid_t folderid) { } pthread_rwlock_rdlock(&crypto_lock); if (!crypto_started_l) { - dec = (pcrypto_textdec_t)err_to_ptr( + dec = (pcrypto_textdec_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_NOT_STARTED)); } else if (folderid > 0) { - dec = psync_crypto_get_folder_decoder_locked(folderid); + dec = get_fldrdecoder_safe(folderid); } else if (folderid < 0) { - dec = psync_crypto_get_temp_folder_decoder_locked(folderid); + dec = get_tmp_fldrdecoder_safe(folderid); } else { - dec = (pcrypto_textdec_t)err_to_ptr( + dec = (pcrypto_textdec_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_FOLDER_NOT_ENCRYPTED)); } pthread_rwlock_unlock(&crypto_lock); @@ -1298,8 +1275,7 @@ void pcryptofolder_flddecoder_release( pcrypto_textdec_free(decoder); } -char * -pcryptofolder_flddecode_filename(pcrypto_textdec_t decoder, +char *pcryptofolder_flddecode_filename(pcrypto_textdec_t decoder, const char *name) { unsigned char *filenameenc, *filenamedec; size_t filenameenclen; @@ -1313,25 +1289,22 @@ pcryptofolder_flddecode_filename(pcrypto_textdec_t decoder, return (char *)filenamedec; } -static void psync_crypto_free_folder_encoder(void *ptr) { - pcrypto_textenc_free( - (pcrypto_textenc_t)ptr); +static void proc_free_direncoder(void *ptr) { + pcrypto_textenc_free((pcrypto_textenc_t)ptr); } -static void psync_crypto_release_folder_encoder_locked( +static void free_direncoder( psync_folderid_t folderid, pcrypto_textenc_t enc) { char buff[16]; psync_get_string_id(buff, "FLDE", folderid); - pcache_add(buff, enc, PSYNC_CRYPTO_CACHE_DIR_ECODER_SEC, - psync_crypto_free_folder_encoder, 2); + pcache_add(buff, enc, PSYNC_CRYPTO_CACHE_DIR_ECODER_SEC, proc_free_direncoder, 2); } -pcrypto_textenc_t -pcryptofolder_fldencoder_get(psync_fsfolderid_t folderid) { +pcrypto_textenc_t pcryptofolder_fldencoder_get(psync_fsfolderid_t folderid) { char buff[16]; pcrypto_textenc_t enc; if (!crypto_started_un) { - return (pcrypto_textenc_t)err_to_ptr( + return (pcrypto_textenc_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_NOT_STARTED)); } @@ -1345,14 +1318,14 @@ pcryptofolder_fldencoder_get(psync_fsfolderid_t folderid) { pthread_rwlock_rdlock(&crypto_lock); if (!crypto_started_l) { - enc = (pcrypto_textenc_t)err_to_ptr( + enc = (pcrypto_textenc_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_NOT_STARTED)); } else if (folderid > 0) { - enc = psync_crypto_get_folder_encoder_locked(folderid); + enc = get_fldr_encoder(folderid); } else if (folderid < 0) { - enc = psync_crypto_get_temp_folder_encoder_locked(folderid); + enc = get_tmp_fldrencoder_safe(folderid); } else { - enc = (pcrypto_textenc_t)err_to_ptr( + enc = (pcrypto_textenc_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_FOLDER_NOT_ENCRYPTED)); } pthread_rwlock_unlock(&crypto_lock); @@ -1365,13 +1338,12 @@ void pcryptofolder_fldencoder_release( if (crypto_started_un && folderid >= 0) { psync_get_string_id(buff, "FLDE", folderid); pcache_add(buff, encoder, PSYNC_CRYPTO_CACHE_DIR_ECODER_SEC, - psync_crypto_free_folder_encoder, 2); + proc_free_direncoder, 2); } else pcrypto_textenc_free(encoder); } -char * -pcryptofolder_fldencode_filename(pcrypto_textenc_t encoder, +char * pcryptofolder_fldencode_filename(pcrypto_textenc_t encoder, const char *name) { unsigned char *filenameenc, *filenameb32; size_t filenameenclen; @@ -1383,14 +1355,13 @@ pcryptofolder_fldencode_filename(pcrypto_textenc_t encoder, return (char *)filenameb32; } -static pcrypto_sector_encdec_t -psync_crypto_get_file_encoder_locked(psync_fileid_t fileid, uint64_t hash, +static pcrypto_sector_encdec_t get_fileencoder(psync_fileid_t fileid, uint64_t hash, int nonetwork) { pcrypto_sector_encdec_t enc; psync_symmetric_key_t symkey, realkey; sym_key_ver1 *skv1; - symkey = psync_crypto_get_file_symkey_locked(fileid, hash, nonetwork); - if (unlikely_log(psync_crypto_is_error(symkey))) + symkey = get_file_symkey_safe(fileid, hash, nonetwork); + if (unlikely_log(is_err(symkey))) return (pcrypto_sector_encdec_t)symkey; if (nonetwork && (pcrypto_sector_encdec_t)symkey == PSYNC_CRYPTO_UNLOADED_SECTOR_ENCODER) @@ -1409,7 +1380,7 @@ psync_crypto_get_file_encoder_locked(psync_fileid_t fileid, uint64_t hash, (unsigned long)fileid); goto def1; } - realkey = psync_crypto_sym_key_ver1_to_sym_key(skv1); + realkey = symkeyv1_to_symkey(skv1); psync_crypto_release_file_symkey_locked(fileid, hash, symkey); enc = pcrypto_sec_encdec_create(realkey); psync_ssl_free_symmetric_key(realkey); @@ -1418,13 +1389,12 @@ psync_crypto_get_file_encoder_locked(psync_fileid_t fileid, uint64_t hash, debug(D_WARNING, "unkown key type %u", (unsigned)skv1->type); def1: psync_ssl_free_symmetric_key(symkey); - return (pcrypto_sector_encdec_t)err_to_ptr( + return (pcrypto_sector_encdec_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY)); } } -static pcrypto_sector_encdec_t -psync_crypto_get_temp_file_encoder_locked(psync_fsfileid_t fileid, +static pcrypto_sector_encdec_t get_fileencoder_tmp(psync_fsfileid_t fileid, int nonetwork) { uint64_t hash; psync_sql_res *res; @@ -1442,7 +1412,7 @@ psync_crypto_get_temp_file_encoder_locked(psync_fsfileid_t fileid, row = psync_sql_fetch_row(res); if (unlikely_log(!row)) { psync_sql_free_result(res); - return (pcrypto_sector_encdec_t)err_to_ptr( + return (pcrypto_sector_encdec_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_FILE_NOT_FOUND)); } switch (psync_get_number(row[0])) { @@ -1457,7 +1427,7 @@ psync_crypto_get_temp_file_encoder_locked(psync_fsfileid_t fileid, } else symkey = PSYNC_INVALID_SYM_KEY; if (symkey == PSYNC_INVALID_SYM_KEY) - return (pcrypto_sector_encdec_t)err_to_ptr( + return (pcrypto_sector_encdec_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY)); skv1 = (sym_key_ver1 *)symkey->key; switch (skv1->type) { @@ -1468,7 +1438,7 @@ psync_crypto_get_temp_file_encoder_locked(psync_fsfileid_t fileid, (unsigned long)symkey->keylen); goto def1; } - realkey = psync_crypto_sym_key_ver1_to_sym_key(skv1); + realkey = symkeyv1_to_symkey(skv1); psync_ssl_free_symmetric_key(symkey); enc = pcrypto_sec_encdec_create(realkey); psync_ssl_free_symmetric_key(realkey); @@ -1477,28 +1447,27 @@ psync_crypto_get_temp_file_encoder_locked(psync_fsfileid_t fileid, debug(D_WARNING, "unkown key type %u", (unsigned)skv1->type); def1: psync_ssl_free_symmetric_key(symkey); - return (pcrypto_sector_encdec_t)err_to_ptr( + return (pcrypto_sector_encdec_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY)); } case PSYNC_FS_TASK_MODIFY: fileid = psync_get_number(row[1]); hash = psync_get_number(row[3]); psync_sql_free_result(res); - return psync_crypto_get_file_encoder_locked(fileid, hash, nonetwork); + return get_fileencoder(fileid, hash, nonetwork); default: psync_sql_free_result(res); - return (pcrypto_sector_encdec_t)err_to_ptr( + return (pcrypto_sector_encdec_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_INTERNAL_ERROR)); } } -pcrypto_sector_encdec_t -pcryptofolder_filencoder_get(psync_fsfileid_t fileid, uint64_t hash, +pcrypto_sector_encdec_t pcryptofolder_filencoder_get(psync_fsfileid_t fileid, uint64_t hash, int nonetwork) { char buff[32]; pcrypto_sector_encdec_t enc; if (!crypto_started_un) - return (pcrypto_sector_encdec_t)err_to_ptr( + return (pcrypto_sector_encdec_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_NOT_STARTED)); if (fileid >= 0) { psync_get_string_id2(buff, "SEEN", fileid, hash); @@ -1508,22 +1477,21 @@ pcryptofolder_filencoder_get(psync_fsfileid_t fileid, uint64_t hash, } pthread_rwlock_rdlock(&crypto_lock); if (!crypto_started_l) { - enc = (pcrypto_sector_encdec_t)err_to_ptr( + enc = (pcrypto_sector_encdec_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_NOT_STARTED)); } else if (fileid > 0) { - enc = psync_crypto_get_file_encoder_locked(fileid, hash, nonetwork); + enc = get_fileencoder(fileid, hash, nonetwork); } else if (fileid < 0) { - enc = psync_crypto_get_temp_file_encoder_locked(fileid, nonetwork); + enc = get_fileencoder_tmp(fileid, nonetwork); } else { - enc = (pcrypto_sector_encdec_t)err_to_ptr( + enc = (pcrypto_sector_encdec_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_FOLDER_NOT_ENCRYPTED)); } pthread_rwlock_unlock(&crypto_lock); return enc; } -pcrypto_sector_encdec_t -pcryptofolder_filencoder_from_binresult(psync_fileid_t fileid, +pcrypto_sector_encdec_t pcryptofolder_filencoder_from_binresult(psync_fileid_t fileid, binresult *res) { const binresult *b64key; unsigned char *key; @@ -1536,7 +1504,7 @@ pcryptofolder_filencoder_from_binresult(psync_fileid_t fileid, key = psync_base64_decode((const unsigned char *)b64key->str, b64key->length, &keylen); if (!key) - return (pcrypto_sector_encdec_t)err_to_ptr( + return (pcrypto_sector_encdec_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY)); esym = psync_ssl_alloc_encrypted_symmetric_key(keylen); memcpy(esym->data, key, keylen); @@ -1545,16 +1513,16 @@ pcryptofolder_filencoder_from_binresult(psync_fileid_t fileid, save_file_key_to_db(fileid, hash, esym); pthread_rwlock_rdlock(&crypto_lock); if (!crypto_started_l) - enc = (pcrypto_sector_encdec_t)err_to_ptr( + enc = (pcrypto_sector_encdec_t)errptr( PRINT_RETURN_CONST(PSYNC_CRYPTO_NOT_STARTED)); else { // save_file_key_to_db runs thread to save to db, that's why we insert - // decrypted key to cache, so psync_crypto_get_file_encoder_locked finds + // decrypted key to cache, so get_fileencoder finds // it symkey = psync_ssl_rsa_decrypt_symm_key_lock(&crypto_privkey, &esym); psync_crypto_release_file_symkey_locked(fileid, hash, symkey); - enc = psync_crypto_get_file_encoder_locked(fileid, hash, 0); + enc = get_fileencoder(fileid, hash, 0); } pthread_rwlock_unlock(&crypto_lock); psync_free(esym); @@ -1578,19 +1546,19 @@ void pcryptofolder_filencoder_release( pcrypto_sec_encdec_free(encoder); } -char *psync_crypto_get_name_encoded_locked(psync_folderid_t folderid, +static char *get_name_encoded(psync_folderid_t folderid, const char *name) { pcrypto_textenc_t enc; unsigned char *nameenc; char *ret; size_t nameenclen; - enc = psync_crypto_get_folder_encoder_check_cache_locked(folderid); - if (psync_crypto_is_error(enc)) + enc = get_fldr_encoder_cache(folderid); + if (is_err(enc)) return (char *)enc; pcrypto_encode_text(enc, (const unsigned char *)name, strlen(name), &nameenc, &nameenclen); ret = (char *)psync_base32_encode(nameenc, nameenclen, &nameenclen); - psync_crypto_release_folder_encoder_locked(folderid, enc); + free_direncoder(folderid, enc); psync_free(nameenc); return ret; } @@ -1610,18 +1578,19 @@ static int set_err(int ret, const char **err) { return ret; } -static int get_name_for_enc_folder_locked(psync_folderid_t folderid, +static int get_cfldr_name(psync_folderid_t folderid, const char *name, char **ename, const char **err) { - char *encname; - encname = psync_crypto_get_name_encoded_locked(folderid, name); - if (psync_crypto_is_error(encname)) - return set_err(psync_crypto_to_error(encname), err); + char *encname; + + encname = get_name_encoded(folderid, name); + if (is_err(encname)) + return set_err(to_err(encname), err); *ename = encname; return PSYNC_CRYPTO_SUCCESS; } -static int get_name_for_folder_locked(psync_folderid_t folderid, +static int get_fldr_name(psync_folderid_t folderid, const char *name, char **ename, const char **err) { if (folderid == 0) { @@ -1639,7 +1608,7 @@ static int get_name_for_folder_locked(psync_folderid_t folderid, if (!row) return set_err(PRINT_RETURN_CONST(PSYNC_CRYPTO_FOLDER_NOT_FOUND), err); if (enc) - return get_name_for_enc_folder_locked(folderid, name, ename, err); + return get_cfldr_name(folderid, name, ename, err); else { *ename = psync_strdup(name); return PSYNC_CRYPTO_SUCCESS; @@ -1693,7 +1662,7 @@ int psync_cloud_crypto_send_mkdir(psync_folderid_t folderid, const char *name, *newfolderid = papi_find_result2(meta, "folderid", PARAM_NUM)->num; psync_sql_start_transaction(); pfileops_create_fldr(meta); - save_folder_key_to_db(papi_find_result2(meta, "folderid", PARAM_NUM)->num, + save_folder_key(papi_find_result2(meta, "folderid", PARAM_NUM)->num, encsym); psync_sql_commit_transaction(); psync_free(res); @@ -1705,9 +1674,9 @@ char *pcryptofolder_filencoder_key_get(psync_fsfileid_t fileid, psync_encrypted_symmetric_key_t encsym; char *ret; if (fileid < 0) - return (char *)err_to_ptr(PRINT_RETURN_CONST(PSYNC_CRYPTO_FILE_NOT_FOUND)); - encsym = psync_crypto_get_file_enc_key(fileid, hash, 0); - if (psync_crypto_is_error(encsym)) + return (char *)errptr(PRINT_RETURN_CONST(PSYNC_CRYPTO_FILE_NOT_FOUND)); + encsym = get_file_enckey(fileid, hash, 0); + if (is_err(encsym)) return (char *)encsym; ret = (char *)psync_base64_encode(encsym->data, encsym->datalen, keylen); psync_free(encsym); @@ -1719,7 +1688,7 @@ char *pcryptofolder_filencoder_key_new(uint32_t flags, size_t *keylen) { sym_key_ver1 sym; char *ret; if (!crypto_started_un) - return (char *)err_to_ptr(PRINT_RETURN_CONST(PSYNC_CRYPTO_NOT_STARTED)); + return (char *)errptr(PRINT_RETURN_CONST(PSYNC_CRYPTO_NOT_STARTED)); sym.type = PSYNC_CRYPTO_SYM_AES256_1024BIT_HMAC; sym.flags = flags; psync_ssl_rand_strong(sym.hmackey, PSYNC_CRYPTO_HMAC_SHA512_KEY_LEN); @@ -1727,14 +1696,14 @@ char *pcryptofolder_filencoder_key_new(uint32_t flags, size_t *keylen) { pthread_rwlock_rdlock(&crypto_lock); if (!crypto_started_l) { pthread_rwlock_unlock(&crypto_lock); - return (char *)err_to_ptr(PRINT_RETURN_CONST(PSYNC_CRYPTO_NOT_STARTED)); + return (char *)errptr(PRINT_RETURN_CONST(PSYNC_CRYPTO_NOT_STARTED)); } encsym = psync_ssl_rsa_encrypt_data(crypto_pubkey, (unsigned char *)&sym, sizeof(sym)); pthread_rwlock_unlock(&crypto_lock); if (encsym == PSYNC_INVALID_ENC_SYM_KEY) { debug(D_ERROR, "RSA encryption failed"); - return (char *)err_to_ptr(PRINT_RETURN_CONST(PSYNC_CRYPTO_RSA_ERROR)); + return (char *)errptr(PRINT_RETURN_CONST(PSYNC_CRYPTO_RSA_ERROR)); } psync_ssl_memclean(&sym, sizeof(sym)); ret = (char *)psync_base64_encode(encsym->data, encsym->datalen, keylen); @@ -1748,7 +1717,7 @@ char *pcryptofolder_filencoder_key_newplain( sym_key_ver1 sym; char *ret; if (!crypto_started_un) - return (char *)err_to_ptr(PRINT_RETURN_CONST(PSYNC_CRYPTO_NOT_STARTED)); + return (char *)errptr(PRINT_RETURN_CONST(PSYNC_CRYPTO_NOT_STARTED)); sym.type = PSYNC_CRYPTO_SYM_AES256_1024BIT_HMAC; sym.flags = flags; psync_ssl_rand_strong(sym.hmackey, PSYNC_CRYPTO_HMAC_SHA512_KEY_LEN); @@ -1756,16 +1725,16 @@ char *pcryptofolder_filencoder_key_newplain( pthread_rwlock_rdlock(&crypto_lock); if (!crypto_started_l) { pthread_rwlock_unlock(&crypto_lock); - return (char *)err_to_ptr(PRINT_RETURN_CONST(PSYNC_CRYPTO_NOT_STARTED)); + return (char *)errptr(PRINT_RETURN_CONST(PSYNC_CRYPTO_NOT_STARTED)); } encsym = psync_ssl_rsa_encrypt_data(crypto_pubkey, (unsigned char *)&sym, sizeof(sym)); pthread_rwlock_unlock(&crypto_lock); if (encsym == PSYNC_INVALID_ENC_SYM_KEY) { debug(D_ERROR, "RSA encryption failed"); - return (char *)err_to_ptr(PRINT_RETURN_CONST(PSYNC_CRYPTO_RSA_ERROR)); + return (char *)errptr(PRINT_RETURN_CONST(PSYNC_CRYPTO_RSA_ERROR)); } - *deckey = psync_crypto_sym_key_ver1_to_sym_key(&sym); + *deckey = symkeyv1_to_symkey(&sym); psync_ssl_memclean(&sym, sizeof(sym)); ret = (char *)psync_base64_encode(encsym->data, encsym->datalen, keylen); psync_free(encsym); @@ -1795,7 +1764,7 @@ int pcryptofolder_mkdir(psync_folderid_t folderid, const char *name, encsym = psync_ssl_rsa_encrypt_data(crypto_pubkey, (unsigned char *)&sym, sizeof(sym)); psync_ssl_memclean(&sym, sizeof(sym)); - ret = get_name_for_folder_locked(folderid, name, &ename, err); + ret = get_fldr_name(folderid, name, &ename, err); pthread_rwlock_unlock(&crypto_lock); if (ret) { if (encsym != PSYNC_INVALID_ENC_SYM_KEY) @@ -1910,11 +1879,11 @@ int psync_pcloud_crypto_reencode_key( goto err_ph_2; psync_sha256(newpriv, newprivlen, newprivsha); rsasign = psync_ssl_rsa_sign_sha256_hash(priv, newprivsha); - if (psync_crypto_is_error(rsasign)) { - psync_free(newpriv); + if (is_err(rsasign)) { + psync_free(is_err); psync_ssl_rsa_free_public(pub); psync_ssl_rsa_free_private(priv); - return psync_crypto_to_error(rsasign); + return to_err(rsasign); } *privenc = (char *)psync_base64_encode(newpriv, newprivlen, &dummy); *sign = (char *)psync_base64_encode(rsasign->data, rsasign->datalen, &dummy); @@ -1985,10 +1954,10 @@ int psync_pcloud_crypto_encode_key(const char *newpassphrase, uint32_t flags, psync_sha256(newpriv, rsaprivlen, newprivsha); rsasign = psync_ssl_rsa_sign_sha256_hash(crypto_privkey, newprivsha); - if (psync_crypto_is_error(rsasign)) { + if (is_err(rsasign)) { psync_free(newpriv); psync_ssl_rsa_free_binary(rsapriv); - return psync_crypto_to_error(rsasign); + return to_err(rsasign); } *privenc = (char *)psync_base64_encode(newpriv, rsaprivlen, &dummy); *sign = (char *)psync_base64_encode(rsasign->data, rsasign->datalen, &dummy); @@ -2031,10 +2000,8 @@ int pcryptofolder_change_pass(const char *oldpassphrase, if (!newpassphrase || !newpassphrase[0]) return PSYNC_CRYPTO_BAD_PASSPHRASE; -retry: - if (psync_sql_trylock()) { + while (psync_sql_trylock()) { psys_sleep_milliseconds(1); - goto retry; } rowcnt = 0; res = psync_sql_query_nolock( @@ -2148,10 +2115,3 @@ int pcryptofolder_change_pass_unlocked(const char *newpassphrase, cres = psync_pcloud_crypto_encode_key(newpassphrase, flags, privenc, sign); return cres; } - -void sha1_hex_null_term(const void *data, size_t len, char *out) { - unsigned char sha1bin[PSYNC_SHA1_DIGEST_LEN]; - psync_sha1((const unsigned char *)data, len, (unsigned char *)sha1bin); - psync_binhex(out, sha1bin, PSYNC_SHA1_DIGEST_LEN); - out[PSYNC_SHA1_DIGEST_HEXLEN] = 0; -} diff --git a/pclsync/pcryptofolder.h b/pclsync/pcryptofolder.h index 80e1c9c..488985d 100644 --- a/pclsync/pcryptofolder.h +++ b/pclsync/pcryptofolder.h @@ -32,10 +32,14 @@ #ifndef __PCRYPTOFOLDER_H #define __PCRYPTOFOLDER_H +#ifdef __cplusplus +extern "C" { +#endif + #include "papi.h" #include "pcrypto.h" +#include "pfoldersync.h" #include "pfsfolder.h" -#include "psynclib.h" #define PSYNC_CRYPTO_SYM_FLAG_ISDIR 1 @@ -74,4 +78,8 @@ int pcryptofolder_reset(); int pcryptofolder_setup(const char *password, const char *hint); int pcryptofolder_unlock(const char *password); +#ifdef __cplusplus +} +#endif + #endif diff --git a/pclsync/pdiff.c b/pclsync/pdiff.c index 67c6533..8451ce8 100644 --- a/pclsync/pdiff.c +++ b/pclsync/pdiff.c @@ -38,6 +38,7 @@ #include #include #include +#include #include "paccountevents.h" #include "papi.h" diff --git a/pclsync/pdownload.c b/pclsync/pdownload.c index c31455a..9dc6f22 100644 --- a/pclsync/pdownload.c +++ b/pclsync/pdownload.c @@ -31,6 +31,7 @@ #include #include #include +#include #include "pqevent.h" #include "pdownload.h" @@ -48,6 +49,7 @@ #include "ptimer.h" #include "pupload.h" #include "ppath.h" +#include "pfile.h" extern const unsigned char pfile_invalid_chars[]; diff --git a/pclsync/pdownload.h b/pclsync/pdownload.h index 3af5644..b69ae3c 100644 --- a/pclsync/pdownload.h +++ b/pclsync/pdownload.h @@ -33,7 +33,7 @@ #define _PSYNC_DOWNLOAD_H #include "psettings.h" -#include "psynclib.h" +#include "pfoldersync.h" typedef unsigned char psync_hex_hash[PSYNC_HASH_DIGEST_HEXLEN]; diff --git a/pclsync/pfolder.c b/pclsync/pfolder.c index 214bbfb..3d4ea94 100644 --- a/pclsync/pfolder.c +++ b/pclsync/pfolder.c @@ -42,6 +42,7 @@ #include "pnetlibs.h" #include "psys.h" #include "ppath.h" +#include "pfile.h" #include #include diff --git a/pclsync/pfs.h b/pclsync/pfs.h index 792e24d..438dbaf 100644 --- a/pclsync/pfs.h +++ b/pclsync/pfs.h @@ -41,7 +41,7 @@ #include "pintervaltree.h" #include "plibs.h" #include "psettings.h" -#include "psynclib.h" +#include "pfoldersync.h" #include "ptimer.h" #include "ptree.h" diff --git a/pclsync/pfstasks.h b/pclsync/pfstasks.h index 03112d8..55bb980 100644 --- a/pclsync/pfstasks.h +++ b/pclsync/pfstasks.h @@ -36,9 +36,9 @@ #include #include +#include "pfoldersync.h" #include "pfsfolder.h" #include "plibs.h" -#include "psynclib.h" #include "ptree.h" #define PSYNC_FS_TASK_MKDIR 1 diff --git a/pclsync/pfsupload.c b/pclsync/pfsupload.c index 1a35bb2..1085ee3 100644 --- a/pclsync/pfsupload.c +++ b/pclsync/pfsupload.c @@ -42,6 +42,7 @@ #include "pcache.h" #include "pdiff.h" +#include "pfile.h" #include "pfileops.h" #include "pfscrypto.h" #include "pfstasks.h" diff --git a/pclsync/pfsupload.h b/pclsync/pfsupload.h index f0c98c2..f9f8520 100644 --- a/pclsync/pfsupload.h +++ b/pclsync/pfsupload.h @@ -32,7 +32,7 @@ #ifndef _PSYNC_FSUPLOAD_H #define _PSYNC_FSUPLOAD_H -#include "psynclib.h" +#include void psync_fsupload_init(); void psync_fsupload_wake(); diff --git a/pclsync/pfsxattr.h b/pclsync/pfsxattr.h index 10b2993..49f4304 100644 --- a/pclsync/pfsxattr.h +++ b/pclsync/pfsxattr.h @@ -32,8 +32,9 @@ #ifndef _PSYNC_FSXATTR_H #define _PSYNC_FSXATTR_H -#include "pfile.h" -#include "psynclib.h" +#include + +#include "pfoldersync.h" #define PFS_XATTR_IGN diff --git a/pclsync/plibs.c b/pclsync/plibs.c index 1af1c7b..c2865d1 100644 --- a/pclsync/plibs.c +++ b/pclsync/plibs.c @@ -42,6 +42,8 @@ #include #include #include +#include +#include "pfile.h" // required by psync_debug extern PSYNC_THREAD const char *psync_thread_name; diff --git a/pclsync/plibs.h b/pclsync/plibs.h index aca3c17..52ec91e 100644 --- a/pclsync/plibs.h +++ b/pclsync/plibs.h @@ -35,10 +35,12 @@ #include #include "pcompiler.h" +#include "pstatus.h" #include "putil.h" -#include "psynclib.h" +#include "psynclib.h" // need for macros... #include +#include #include #define D_NONE 0 diff --git a/pclsync/plocalnotify.h b/pclsync/plocalnotify.h index db34277..2a943bb 100644 --- a/pclsync/plocalnotify.h +++ b/pclsync/plocalnotify.h @@ -32,7 +32,7 @@ #ifndef _PSYNC_LOCALNOTIFY_H #define _PSYNC_LOCALNOTIFY_H -#include "psynclib.h" +#include "pfoldersync.h" int psync_localnotify_init(); void psync_localnotify_add_sync(psync_syncid_t syncid); diff --git a/pclsync/plocalscan.h b/pclsync/plocalscan.h index 27a8928..641eec7 100644 --- a/pclsync/plocalscan.h +++ b/pclsync/plocalscan.h @@ -32,7 +32,7 @@ #ifndef _PSYNC_LOCALSCAN_H #define _PSYNC_LOCALSCAN_H -#include "psynclib.h" +#include "pfoldersync.h" void psync_localscan_init(); void psync_wake_localscan(); diff --git a/pclsync/pnetlibs.c b/pclsync/pnetlibs.c index f22da0f..1c6e273 100644 --- a/pclsync/pnetlibs.c +++ b/pclsync/pnetlibs.c @@ -36,13 +36,6 @@ #include #include -#include -#include -#include -#include -#include -#include - #include "papi.h" #include "pcache.h" #include "pdevice.h" @@ -56,6 +49,7 @@ #include "ppath.h" #include "psys.h" #include "ptree.h" +#include "pfile.h" // required by psync_send_debug extern PSYNC_THREAD const char *psync_thread_name; diff --git a/pclsync/pnetlibs.h b/pclsync/pnetlibs.h index 9d5ed86..871b34d 100644 --- a/pclsync/pnetlibs.h +++ b/pclsync/pnetlibs.h @@ -33,9 +33,8 @@ #define _PSYNC_NETLIBS_H #include "papi.h" -#include "pfile.h" #include "plist.h" -#include "psynclib.h" +#include "pfoldersync.h" #define senddebug(str, ...) \ do { \ diff --git a/pclsync/pnotify.c b/pclsync/pnotify.c index a959a84..cf0c6b7 100644 --- a/pclsync/pnotify.c +++ b/pclsync/pnotify.c @@ -33,10 +33,10 @@ #include "plibs.h" #include "pnetlibs.h" #include "psettings.h" -#include "ptimer.h" #include "ptree.h" #include "ppath.h" #include "prun.h" +#include "pfile.h" typedef struct { diff --git a/pclsync/ppagecache.c b/pclsync/ppagecache.c index 20f8a61..f99fc40 100644 --- a/pclsync/ppagecache.c +++ b/pclsync/ppagecache.c @@ -49,6 +49,7 @@ #include "ppath.h" #include "psys.h" #include "putil.h" +#include "pfile.h" #include "pstatus.h" #include "ptimer.h" diff --git a/pclsync/pssl.h b/pclsync/pssl.h index 32babbe..8c62d46 100644 --- a/pclsync/pssl.h +++ b/pclsync/pssl.h @@ -50,33 +50,27 @@ #define PSYNC_SHA1_DIGEST_LEN 20 #define PSYNC_SHA1_DIGEST_HEXLEN 40 #define psync_sha1_ctx mbedtls_sha1_context -#define psync_sha1(data, datalen, checksum) \ - mbedtls_sha1(data, datalen, checksum) +#define psync_sha1(data, datalen, checksum) mbedtls_sha1(data, datalen, checksum) #define psync_sha1_init(pctx) mbedtls_sha1_starts(pctx) -#define psync_sha1_update(pctx, data, datalen) \ - mbedtls_sha1_update(pctx, (const unsigned char *)data, datalen) +#define psync_sha1_update(pctx, data, datalen) mbedtls_sha1_update(pctx, (const unsigned char *)data, datalen) #define psync_sha1_final(checksum, pctx) mbedtls_sha1_finish(pctx, checksum) #define PSYNC_SHA256_BLOCK_LEN 64 #define PSYNC_SHA256_DIGEST_LEN 32 #define PSYNC_SHA256_DIGEST_HEXLEN 64 #define psync_sha256_ctx mbedtls_sha256_context -#define psync_sha256(data, datalen, checksum) \ - mbedtls_sha256(data, datalen, checksum, 0) +#define psync_sha256(data, datalen, checksum) mbedtls_sha256(data, datalen, checksum, 0) #define psync_sha256_init(pctx) mbedtls_sha256_starts(pctx, 0) -#define psync_sha256_update(pctx, data, datalen) \ - mbedtls_sha256_update(pctx, (const unsigned char *)data, datalen) +#define psync_sha256_update(pctx, data, datalen) mbedtls_sha256_update(pctx, (const unsigned char *)data, datalen) #define psync_sha256_final(checksum, pctx) mbedtls_sha256_finish(pctx, checksum) #define PSYNC_SHA512_BLOCK_LEN 128 #define PSYNC_SHA512_DIGEST_LEN 64 #define PSYNC_SHA512_DIGEST_HEXLEN 128 #define psync_sha512_ctx mbedtls_sha512_context -#define psync_sha512(data, datalen, checksum) \ - mbedtls_sha512(data, datalen, checksum, 0) +#define psync_sha512(data, datalen, checksum) mbedtls_sha512(data, datalen, checksum, 0) #define psync_sha512_init(pctx) mbedtls_sha512_starts(pctx, 0) -#define psync_sha512_update(pctx, data, datalen) \ - mbedtls_sha512_update(pctx, (const unsigned char *)data, datalen) +#define psync_sha512_update(pctx, data, datalen) mbedtls_sha512_update(pctx, (const unsigned char *)data, datalen) #define psync_sha512_final(checksum, pctx) mbedtls_sha512_finish(pctx, checksum) typedef mbedtls_rsa_context *psync_rsa_t; diff --git a/pclsync/pstatus.h b/pclsync/pstatus.h index ddee192..7246dc9 100644 --- a/pclsync/pstatus.h +++ b/pclsync/pstatus.h @@ -31,6 +31,10 @@ #ifndef _PSYNC_STATUS_H #define _PSYNC_STATUS_H +#ifdef __cplusplus +extern "C" { +#endif + #include #include "plist.h" @@ -155,4 +159,8 @@ void pstatus_get_cb(pstatus_t *status); void pstatus_set_cb(pstatus_change_callback_t callback); void pstatus_send_status_update(); +#ifdef __cplusplus +} +#endif + #endif diff --git a/pclsync/ptask.c b/pclsync/ptask.c index c854fb5..d842969 100644 --- a/pclsync/ptask.c +++ b/pclsync/ptask.c @@ -1055,3 +1055,30 @@ int ptask_download_needed_async(psync_fileid_t fileid, task.request.cbext = cbext; return task_send_async(&task, sizeof(task)); } + +void ptask_cfldr_save_fldrkey(void *ptr) { + insert_folder_key_task *t; + psync_sql_res *res; + t = (insert_folder_key_task *)ptr; + res = psync_sql_prep_statement( + "REPLACE INTO cryptofolderkey (folderid, enckey) VALUES (?, ?)"); + psync_sql_bind_uint(res, 1, t->id); + psync_sql_bind_blob(res, 2, (const char *)t->key->data, t->key->datalen); + psync_sql_run_free(res); + psync_free(t->key); + psync_free(t); +} + +void ptask_cfldr_save_filekey(void *ptr) { + insert_file_key_task *t; + psync_sql_res *res; + t = (insert_file_key_task *)ptr; + res = psync_sql_prep_statement( + "REPLACE INTO cryptofilekey (fileid, hash, enckey) VALUES (?, ?, ?)"); + psync_sql_bind_uint(res, 1, t->id); + psync_sql_bind_uint(res, 2, t->hash); + psync_sql_bind_blob(res, 3, (const char *)t->key->data, t->key->datalen); + psync_sql_run_free(res); + psync_free(t->key); + psync_free(t); +} \ No newline at end of file diff --git a/pclsync/ptask.h b/pclsync/ptask.h index 838610f..c3d3d67 100644 --- a/pclsync/ptask.h +++ b/pclsync/ptask.h @@ -32,15 +32,12 @@ #ifndef _PSYNC_TASKS_H #define _PSYNC_TASKS_H -#include "psynclib.h" +#include "pfoldersync.h" +#include "pssl.h" -#define PSYNC_ASYNC_ERR_FLAG_PERM \ - 0x01 // the error is permanent(ish) and there is no reason to retry -#define PSYNC_ASYNC_ERR_FLAG_RETRY_AS_IS \ - 0x02 // same request may succeed in the future if retried as is -#define PSYNC_ASYNC_ERR_FLAG_SUCCESS \ - 0x04 // like no action performed because of no need - file already exists and - // so on +#define PSYNC_ASYNC_ERR_FLAG_PERM 0x01 // the error is permanent(ish) and there is no reason to retry +#define PSYNC_ASYNC_ERR_FLAG_RETRY_AS_IS 0x02 // same request may succeed in the future if retried as is +#define PSYNC_ASYNC_ERR_FLAG_SUCCESS 0x04 // like no action performed because of no need - file already exists and so on #define PSYNC_ASYNC_ERROR_NET 1 #define PSYNC_ASYNC_ERROR_FILE 2 @@ -119,6 +116,17 @@ typedef struct { }; } psync_async_result_t; +typedef struct { + psync_encrypted_symmetric_key_t key; + psync_fileid_t id; + uint64_t hash; +} insert_file_key_task; + +typedef struct { + psync_encrypted_symmetric_key_t key; + psync_folderid_t id; +} insert_folder_key_task; + typedef void (*psync_async_callback_t)(void *, psync_async_result_t *); @@ -154,4 +162,8 @@ void ptask_download_q(psync_syncid_t syncid, psync_fileid_t fileid, psync_folder void ptask_upload(psync_syncid_t syncid, psync_fileid_t localfileid, const char *name); void ptask_upload_q(psync_syncid_t syncid, psync_fileid_t localfileid, const char *name); +// crypto folder +void ptask_cfldr_save_fldrkey(void *ptr); +void ptask_cfldr_save_filekey(void *ptr); + #endif diff --git a/pclsync/ptools.c b/pclsync/ptools.c index 461cbdc..c81e07d 100644 --- a/pclsync/ptools.c +++ b/pclsync/ptools.c @@ -47,6 +47,7 @@ #include #include #include +#include char *ptools_get_mac_addr() { char buffer[128]; diff --git a/pclsync_lib.cpp b/pclsync_lib.cpp index 25f79c4..6285602 100644 --- a/pclsync_lib.cpp +++ b/pclsync_lib.cpp @@ -37,10 +37,12 @@ #include #include +#include "pcryptofolder.h" #include "prpc.h" #include "psynclib.h" #include "pshm.h" #include "pdevice.h" +#include "pcommands.h" #include "pclsync_lib.h" @@ -199,28 +201,35 @@ void event_handler(psync_eventtype_t event, psync_eventdata_t eventdata) { } static int lib_setup_cripto() { - int ret = 0; - ret = psync_crypto_issetup(); - if (ret) { - ret = psync_crypto_start( - clib::pclsync_lib::get_lib().get_crypto_pass().c_str()); - std::cout << "crypto is setup, login result=" << ret << std::endl; - } else { - std::cout << "crypto is not setup" << std::endl; - ret = psync_crypto_setup( - clib::pclsync_lib::get_lib().get_crypto_pass().c_str(), "no hint"); - if (ret) { - std::cout << "crypto setup failed" << std::endl; - } else { - ret = psync_crypto_start( - clib::pclsync_lib::get_lib().get_crypto_pass().c_str()); - std::cout << "crypto setup successful, start=" << ret << std::endl; - ret = psync_crypto_mkdir(0, "Crypto", NULL, NULL); - std::cout << "creating folder=" << ret << std::endl; - } + const char *pwd = clib::pclsync_lib::get_lib().get_crypto_pass().c_str(); + + if(pstatus_get(PSTATUS_TYPE_ONLINE) == PSTATUS_ONLINE_OFFLINE) { + std::cout << "Cannot unlock crypto folder, pcloudcc is offline" << std::endl; + return PSYNC_CRYPTO_CANT_CONNECT; } + + if(!psync_crypto_issetup()) { + std::cout << "crypto is not setup, setting it up now..." << std::endl; + if(int ret = pcryptofolder_setup(pwd, "no hint") != PSYNC_CRYPTO_SETUP_SUCCESS) { + std::cout << "crypto setup failed, error code was " << ret << std::endl; + return ret; + } + if(int ret = pcryptofolder_mkdir(0, "Crypto", NULL, NULL) != PSYNC_CRYPTO_SUCCESS) { + std::cout << "failed to create crypto directory, error code was" << ret << std::endl; + return ret; + } + std::cout << "crypto folder was setup using the provided password, " + << "you may want to change your password hint on the " + << "pcloud website." << std::endl; + } + + if(int ret = pcryptofolder_unlock(pwd) != PSYNC_CRYPTO_START_SUCCESS) { + std::cout << "Failed to unlock crypto folder: error code was " << ret << std::endl; + return ret; + } + clib::pclsync_lib::get_lib().crypto_on_ = true; - return ret; + return 0; } static const char *status2string(uint32_t status) { @@ -450,12 +459,12 @@ int clib::pclsync_lib::init() { psync_free(username_old); } - psync_overlay_register_callback(20, &clib::pclsync_lib::start_crypto); - psync_overlay_register_callback(21, &clib::pclsync_lib::stop_crypto); - psync_overlay_register_callback(22, &clib::pclsync_lib::finalize); - psync_overlay_register_callback(23, &clib::pclsync_lib::list_sync_folders); - psync_overlay_register_callback(24, &clib::pclsync_lib::add_sync_folder); - psync_overlay_register_callback(25, &clib::pclsync_lib::remove_sync_folder); + psync_overlay_register_callback(STARTCRYPTO, &clib::pclsync_lib::start_crypto); + psync_overlay_register_callback(STOPCRYPTO, &clib::pclsync_lib::stop_crypto); + psync_overlay_register_callback(FINALIZE, &clib::pclsync_lib::finalize); + psync_overlay_register_callback(LISTSYNC, &clib::pclsync_lib::list_sync_folders); + psync_overlay_register_callback(ADDSYNC, &clib::pclsync_lib::add_sync_folder); + psync_overlay_register_callback(STOPSYNC, &clib::pclsync_lib::remove_sync_folder); return 0; }