rayelliott
/
barrier
mirror of https://github.com/debauchee/barrier.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

#5657 Extracted shared code between GUI and core

This commit is contained in:
Jerry (Xinyu Hou) 2016-10-13 13:53:09 +01:00
parent 82e55702ef
commit 92680b2877
7 changed files with 141 additions and 383 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/lib/CMakeLists.txt
View File

@ -25,7 +25,7 @@ add_subdirectory(net)
add_subdirectory(platform)
add_subdirectory(server)
add_subdirectory(synergy)
add_subdirectory(shared)
if (WIN32)
add_subdirectory(synwinhk)

26
src/lib/shared/CMakeLists.txt Normal file
View File

@ -0,0 +1,26 @@
# synergy -- mouse and keyboard sharing utility
# Copyright (C) 2016 Symless Ltd.
#
# This package is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# found in the file LICENSE that should have accompanied this file.
#
# This package is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
file(GLOB headers "*.h")
file(GLOB sources "*.cpp")
if (SYNERGY_ADD_HEADERS)
list(APPEND sources ${headers})
endif()
add_library(shared STATIC ${sources})
target_link_libraries(shared arch base)

22
src/lib/synergy/SubscriptionKey.h → src/lib/shared/SerialKey.h
View File

@ -17,13 +17,23 @@
#pragma once
#include "base/String.h"
#include <string>
struct SubscriptionKey {
String m_name;
String m_type;
String m_email;
String m_company;
class SerialKey {
public:
SerialKey(std::string serial);
bool isValid(unsigned long long currentTime) const;
bool isExpiring(unsigned long long currentTime) const;
bool isExpired(unsigned long long currentTime) const;
bool isTrial() const;
int edition() const;
private:
std::string m_name;
std::string m_type;
std::string m_email;
std::string m_company;
int m_userLimit;
int m_warnTime;
int m_expireTime;

222
src/lib/synergy/SubscriptionManager.cpp
View File

@ -1,222 +0,0 @@
/*
* synergy -- mouse and keyboard sharing utility
* Copyright (C) 2015 Synergy Seamless Inc.
*
* This package is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* found in the file LICENSE that should have accompanied this file.
*
* This package is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "synergy/SubscriptionManager.h"
#include "synergy/XSynergy.h"
#include "arch/Arch.h"
#include "base/Log.h"
#include "base/String.h"
#include "common/Version.h"
#include <fstream>
#include <iostream>
#include <algorithm>
#include <vector>
#include <ctime>
//#include <stdexcept>
#if SYSAPI_WIN32
const char* kFile = "Synergy.subkey";
#else
const char* kFile = ".synergy.subkey";
#endif
//
// SubscriptionManager
//
SubscriptionManager::SubscriptionManager() :
m_key()
{
}
void
SubscriptionManager::checkFile(const String& filename_)
{
String filename = filename_;
if (filename.empty()) {
filename = getFilename();
}
std::ifstream stream(filename.c_str());
if (!stream.is_open()) {
throw XSubscription(synergy::string::sprintf(
"Could not open, path=%s", filename.c_str()));
}
String serial;
stream >> serial;
String plainText = decode(serial);
parsePlainSerial(plainText, m_key);
LOG((CLOG_DEBUG "subscription is valid"));
}
void
SubscriptionManager::activate(const String& serial)
{
String plainText = decode(serial);
parsePlainSerial(plainText, m_key);
String filename = getFilename();
std::ofstream stream(filename.c_str());
if (!stream.is_open()) {
throw XSubscription(synergy::string::sprintf(
"Could not open, file=%s", filename.c_str()));
}
stream << serial << std::endl;
LOG((CLOG_DEBUG "subscription file created, path=%s", filename.c_str()));
}
String
SubscriptionManager::decode(const String& input)
{
static const char* const lut = "0123456789ABCDEF";
size_t len = input.length();
if (len & 1) {
throw XSubscription("Invalid serial, wrong length.");
}
String output;
output.reserve(len / 2);
for (size_t i = 0; i < len; i += 2) {
char a = input[i];
char b = input[i + 1];
const char* p = std::lower_bound(lut, lut + 16, a);
const char* q = std::lower_bound(lut, lut + 16, b);
if (*q != b || *p != a) {
throw XSubscription("Invalid serial, unrecognized digit.");
}
output.push_back(static_cast<char>(((p - lut) << 4) | (q - lut)));
}
return output;
}
void
SubscriptionManager::parsePlainSerial(const String& plainText, SubscriptionKey& key)
{
String serial;
String parityStart = plainText.substr(0, 1);
String parityEnd = plainText.substr(plainText.length() - 1, 1);
// check for parity chars { and }, record parity result, then remove them.
if (parityStart == "{" && parityEnd == "}") {
serial = plainText.substr(1, plainText.length() - 2);
// tokenize serialised subscription.
std::vector<String> parts;
std::string::size_type pos = 0;
bool look = true;
while (look) {
std::string::size_type start = pos;
pos = serial.find(";", pos);
if (pos == String::npos) {
pos = plainText.length();
look = false;
}
parts.push_back(serial.substr(start, pos - start));
pos += 1;
}
bool validSerial = false;
if ((parts.size() == 8)
&& (parts.at(0).find("v1") != String::npos)) {
// e.g.: {v1;basic;Bob;1;email;company name;1398297600;1398384000}
key.m_type = parts.at(1);
key.m_name = parts.at(2);
sscanf(parts.at(3).c_str(), "%d", &key.m_userLimit);
key.m_email = parts.at(4);
key.m_company = parts.at(5);
sscanf(parts.at(6).c_str(), "%d", &key.m_warnTime);
sscanf(parts.at(7).c_str(), "%d", &key.m_expireTime);
validSerial = true;
}
else if ((parts.size() == 9)
&& (parts.at(0).find("v2") != String::npos)) {
// e.g.: {v2;trial;basic;Bob;1;email;company name;1398297600;1398384000}
key.m_trial = parts.at(1) == "trial" ? true : false;
key.m_type = parts.at(2);
key.m_name = parts.at(3);
sscanf(parts.at(4).c_str(), "%d", &key.m_userLimit);
key.m_email = parts.at(5);
key.m_company = parts.at(6);
sscanf(parts.at(7).c_str(), "%d", &key.m_warnTime);
sscanf(parts.at(8).c_str(), "%d", &key.m_expireTime);
// only limit to trial version
if (key.m_trial) {
if (time(0) > key.m_expireTime) {
throw XSubscription("trial has expired");
}
else if (time(0) > key.m_warnTime) {
int secLeft = key.m_expireTime - static_cast<int>(time(0));
const int spd = 60 * 60 * 24;
int dayLeft = secLeft / spd + 1;
LOG((CLOG_NOTE "trial will end in %d %s",
dayLeft,
dayLeft == 1 ? "day" : "days"));
}
else {
}
}
validSerial = true;
}
if (validSerial) {
const char* userText = (key.m_userLimit == 1) ? "user" : "users";
LOG((CLOG_INFO "%s subscription valid is for %d %s, registered to %s",
key.m_type.c_str(),
key.m_userLimit,
userText,
key.m_name.c_str()));
return;
}
}
throw XSubscription(synergy::string::sprintf("Serial is invalid."));
}
String
SubscriptionManager::getFilename()
{
String path = ARCH->getProfileDirectory();
path = ARCH->concatPath(path, kFile);
if (path.empty()) {
throw XSubscription("Could not get filename.");
}
return path;
}
void
SubscriptionManager::printFilename()
{
std::cout << getFilename() << std::endl;
}

55
src/lib/synergy/SubscriptionManager.h
View File

@ -1,55 +0,0 @@
/*
* synergy -- mouse and keyboard sharing utility
* Copyright (C) 2015 Synergy Seamless Inc.
*
* This package is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* found in the file LICENSE that should have accompanied this file.
*
* This package is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "SubscriptionKey.h"
#include "common/common.h"
#include "gtest/gtest_prod.h"
class SubscriptionManager {
public:
SubscriptionManager();
//! Check the subscription activation file
void checkFile(const String& filename);
//! Create a subscription activation file based on a serial
void activate(const String& serial);
//! Use standard output to return subscription filename to gui
void printFilename();
private:
FRIEND_TEST(SubscriptionTests, decode_invalidLength_throwException);
FRIEND_TEST(SubscriptionTests, decode_invalidSerial_outputPlainText);
FRIEND_TEST(SubscriptionTests, decode_unrecognizedDigit_throwException);
FRIEND_TEST(SubscriptionTests, parsePlainSerial_noParity_throwException);
FRIEND_TEST(SubscriptionTests, parsePlainSerial_invalidSerial_throwException);
FRIEND_TEST(SubscriptionTests, parsePlainSerial_validSerial_validSubscriptionKey);
FRIEND_TEST(SubscriptionTests, parsePlainSerial_expiredTrialSerial_throwException);
FRIEND_TEST(SubscriptionTests, parsePlainSerial_expiredBasicSerial_validSubscriptionKey);
FRIEND_TEST(SubscriptionTests, parsePlainSerial_validSerialWithoutCompany_validSubscriptionKey);
private:
String decode(const String& input);
void parsePlainSerial(const String& plainText, SubscriptionKey& key);
String getFilename();
SubscriptionKey m_key;
};

1
src/lib/synergy/ToolApp.cpp
View File

@ -18,7 +18,6 @@
#include "synergy/ToolApp.h"
#include "synergy/ArgParser.h"
#include "synergy/SubscriptionManager.h"
#include "arch/Arch.h"
#include "base/Log.h"
#include "base/String.h"

196
src/test/unittests/synergy/SubscriptionTests.cpp
View File

@ -14,101 +14,101 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "synergy/SubscriptionManager.h"
#include "synergy/XSynergy.h"
#include "test/global/gtest.h"
TEST(SubscriptionTests, decode_invalidLength_throwException)
{
SubscriptionManager subscriptionManager;
String serial("ABC");
EXPECT_THROW(subscriptionManager.decode(serial), XSubscription);
}
TEST(SubscriptionTests, decode_unrecognizedDigit_throwException)
{
SubscriptionManager subscriptionManager;
String serial("MOCK");
EXPECT_THROW(subscriptionManager.decode(serial), XSubscription);
}
TEST(SubscriptionTests, parsePlainSerial_noParity_throwException)
{
SubscriptionManager subscriptionManager;
String painText("MOCK");
SubscriptionKey key;
EXPECT_THROW(subscriptionManager.parsePlainSerial(painText, key), XSubscription);
}
TEST(SubscriptionTests, parsePlainSerial_invalidSerial_throwException)
{
SubscriptionManager subscriptionManager;
String painText("{MOCK}");
SubscriptionKey key;
EXPECT_THROW(subscriptionManager.parsePlainSerial(painText, key), XSubscription);
}
TEST(SubscriptionTests, parsePlainSerial_validSerial_validSubscriptionKey)
{
// valid until 2 March 2049
SubscriptionManager subscriptionManager;
String painText("{v1;trial;Bob;1;a@a.a;mock company;2147483647;2147483647}");
SubscriptionKey key;
subscriptionManager.parsePlainSerial(painText, key);
EXPECT_EQ("trial", key.m_type);
EXPECT_EQ("Bob", key.m_name);
EXPECT_EQ(1, key.m_userLimit);
EXPECT_EQ("a@a.a", key.m_email);
EXPECT_EQ("mock company", key.m_company);
EXPECT_EQ(2147483647, key.m_warnTime);
EXPECT_EQ(2147483647, key.m_expireTime);
}
TEST(SubscriptionTests, parsePlainSerial_validSerialWithoutCompany_validSubscriptionKey)
{
// valid until 2 March 2049
SubscriptionManager subscriptionManager;
String painText("{v1;trial;Bob;1;a@a.a;;2147483647;2147483647}");
SubscriptionKey key;
subscriptionManager.parsePlainSerial(painText, key);
EXPECT_EQ("trial", key.m_type);
EXPECT_EQ("Bob", key.m_name);
EXPECT_EQ(1, key.m_userLimit);
EXPECT_EQ("a@a.a", key.m_email);
EXPECT_EQ("", key.m_company);
EXPECT_EQ(2147483647, key.m_warnTime);
EXPECT_EQ(2147483647, key.m_expireTime);
}
TEST(SubscriptionTests, parsePlainSerial_expiredTrialSerial_throwException)
{
SubscriptionManager subscriptionManager;
String painText("{v1;trial;Bob;1;1398297600;1398384000}");
SubscriptionKey key;
EXPECT_THROW(subscriptionManager.parsePlainSerial(painText, key), XSubscription);
}
TEST(SubscriptionTests, parsePlainSerial_expiredBasicSerial_validSubscriptionKey)
{
SubscriptionManager subscriptionManager;
String painText("{v1;basic;Bob;1;a@a.a;mock company;1398297600;1398384000}");
SubscriptionKey key;
subscriptionManager.parsePlainSerial(painText, key);
EXPECT_EQ("basic", key.m_type);
EXPECT_EQ("Bob", key.m_name);
EXPECT_EQ(1, key.m_userLimit);
EXPECT_EQ("a@a.a", key.m_email);
EXPECT_EQ("mock company", key.m_company);
EXPECT_EQ(1398297600, key.m_warnTime);
EXPECT_EQ(1398384000, key.m_expireTime);
}
//
//#include "synergy/LicenseManager.h"
//#include "synergy/XSynergy.h"
//
//#include "test/global/gtest.h"
//
//TEST(SubscriptionTests, decode_invalidLength_throwException)
//{
// LicenseManager LicenseManager;
// String serial("ABC");
//
// EXPECT_THROW(LicenseManager.decode(serial), XSubscription);
//}
//
//TEST(SubscriptionTests, decode_unrecognizedDigit_throwException)
//{
// LicenseManager LicenseManager;
// String serial("MOCK");
//
// EXPECT_THROW(LicenseManager.decode(serial), XSubscription);
//}
//
//TEST(SubscriptionTests, parsePlainSerial_noParity_throwException)
//{
// LicenseManager LicenseManager;
// String painText("MOCK");
// SubscriptionKey key;
//
// EXPECT_THROW(LicenseManager.parsePlainSerial(painText, key), XSubscription);
//}
//
//TEST(SubscriptionTests, parsePlainSerial_invalidSerial_throwException)
//{
// LicenseManager LicenseManager;
// String painText("{MOCK}");
// SubscriptionKey key;
//
// EXPECT_THROW(LicenseManager.parsePlainSerial(painText, key), XSubscription);
//}
//
//TEST(SubscriptionTests, parsePlainSerial_validSerial_validSubscriptionKey)
//{
// // valid until 2 March 2049
// LicenseManager LicenseManager;
// String painText("{v1;trial;Bob;1;a@a.a;mock company;2147483647;2147483647}");
// SubscriptionKey key;
// LicenseManager.parsePlainSerial(painText, key);
//
// EXPECT_EQ("trial", key.m_type);
// EXPECT_EQ("Bob", key.m_name);
// EXPECT_EQ(1, key.m_userLimit);
// EXPECT_EQ("a@a.a", key.m_email);
// EXPECT_EQ("mock company", key.m_company);
// EXPECT_EQ(2147483647, key.m_warnTime);
// EXPECT_EQ(2147483647, key.m_expireTime);
//}
//
//TEST(SubscriptionTests, parsePlainSerial_validSerialWithoutCompany_validSubscriptionKey)
//{
// // valid until 2 March 2049
// LicenseManager LicenseManager;
// String painText("{v1;trial;Bob;1;a@a.a;;2147483647;2147483647}");
// SubscriptionKey key;
// LicenseManager.parsePlainSerial(painText, key);
//
// EXPECT_EQ("trial", key.m_type);
// EXPECT_EQ("Bob", key.m_name);
// EXPECT_EQ(1, key.m_userLimit);
// EXPECT_EQ("a@a.a", key.m_email);
// EXPECT_EQ("", key.m_company);
// EXPECT_EQ(2147483647, key.m_warnTime);
// EXPECT_EQ(2147483647, key.m_expireTime);
//}
//
//TEST(SubscriptionTests, parsePlainSerial_expiredTrialSerial_throwException)
//{
// LicenseManager LicenseManager;
// String painText("{v1;trial;Bob;1;1398297600;1398384000}");
// SubscriptionKey key;
//
// EXPECT_THROW(LicenseManager.parsePlainSerial(painText, key), XSubscription);
//}
//
//TEST(SubscriptionTests, parsePlainSerial_expiredBasicSerial_validSubscriptionKey)
//{
// LicenseManager LicenseManager;
// String painText("{v1;basic;Bob;1;a@a.a;mock company;1398297600;1398384000}");
// SubscriptionKey key;
// LicenseManager.parsePlainSerial(painText, key);
//
// EXPECT_EQ("basic", key.m_type);
// EXPECT_EQ("Bob", key.m_name);
// EXPECT_EQ(1, key.m_userLimit);
// EXPECT_EQ("a@a.a", key.m_email);
// EXPECT_EQ("mock company", key.m_company);
// EXPECT_EQ(1398297600, key.m_warnTime);
// EXPECT_EQ(1398384000, key.m_expireTime);
//}