+++ /dev/null
-#include <stdlib.h>\r
-#include <stdio.h>\r
-#include <signal.h>\r
-#include <unistd.h>\r
-#include <execinfo.h>\r
-#include <wait.h>\r
-#include <string.h>\r
-#include <errno.h>\r
-\r
-#include "main_def.h"\r
-\r
-#include "daemon.h"\r
-\r
-#include "utils.h"\r
-\r
-using namespace NMD;\r
-\r
-/*******************************************************/\r
-/*******************************************************/\r
-int daemon::run()\r
-{\r
- sigset_t sigset;\r
- int signo;\r
-\r
- write_log("[DAEMON] started\n");\r
-\r
- m_sigact.sa_flags = SA_SIGINFO;\r
- m_sigact.sa_sigaction = daemon::err_signal_handler;\r
- sigemptyset(&m_sigact.sa_mask);\r
- sigaction(SIGFPE, &m_sigact, 0);\r
- sigaction(SIGILL, &m_sigact, 0);\r
- sigaction(SIGSEGV, &m_sigact, 0);\r
- sigaction(SIGBUS, &m_sigact, 0);\r
-\r
- sigemptyset(&sigset);\r
- sigaddset(&sigset, SIGQUIT);\r
- sigaddset(&sigset, SIGINT);\r
- sigaddset(&sigset, SIGTERM);\r
- sigaddset(&sigset, SIGUSR1);\r
- sigprocmask(SIG_BLOCK, &sigset, NULL);\r
-\r
- if(threads_init())\r
- {\r
- while(true)\r
- {\r
- sigwait(&sigset, &signo);\r
- write_log("[DAEMON] signal %s\n", strsignal(signo));\r
- break;\r
- }\r
-\r
- threads_done();\r
- }\r
- else\r
- {\r
- write_log("[DAEMON] can't create threads\n");\r
- }\r
-\r
- write_log("[DAEMON] stopped\n");\r
-\r
- return NMD_NEED_TERMINATE;\r
-}\r
-\r
-/*******************************************************/\r
-/*******************************************************/\r
-bool daemon::threads_init()\r
-{\r
- return m_main_thread.start();\r
-}\r
-void daemon::threads_done()\r
-{\r
- m_main_thread.stop();\r
-}\r
-\r
-/*******************************************************/\r
-/*******************************************************/\r
-/*static*/ void daemon::err_signal_handler(int _signo, siginfo_t* _signal_info, void* _ptr)\r
-{\r
-#if 0\r
- void* error_addr;\r
- void* trace[16];\r
- int trace_size;\r
- char** messages;\r
-\r
- write_log("[DAEMON] signal: %s, addr: 0x%0.16X\n", strsignal(_signo), _signal_info->si_addr);\r
-\r
-#if(__WORDSIZE == 64)\r
- error_addr = (void*)((ucontext_t*)_ptr)->uc_mcontext.gregs[REG_RIP];\r
-#else\r
- error_addr = (void*)((ucontext_t*)_ptr)->uc_mcontext.gregs[REG_EIP];\r
-#endif\r
-\r
- trace_size = backtrace(trace, 16);\r
- trace[1] = error_addr;\r
-\r
- messages = backtrace_symbols(trace, trace_size);\r
-\r
- if(messages)\r
- {\r
- write_log("=== backtrace begin ===\n");\r
-\r
- for(int i = 1; i < trace_size; i++)\r
- write_log("%s\n", messages[i]);\r
-\r
- write_log("=== backtrace end ===\n");\r
-\r
- free(messages);\r
- }\r
-#endif\r
-\r
- daemon* pd = reinterpret_cast<daemon*>(_signal_info->si_value.sival_ptr);\r
- pd->threads_done();\r
-\r
- write_log("[DAEMON] stopped\n");\r
-\r
- exit(NMD_NEED_RESTART);\r
-}\r
+++ /dev/null
-#ifndef __DAEMON_H__\r
-#define __DAEMON_H__\r
-\r
-#include "main_thread.h"\r
-\r
-namespace NMD\r
-{\r
-\r
-/*******************************************************/\r
-/*******************************************************/\r
-class daemon final\r
-{\r
-public:\r
- daemon() = default;\r
- daemon(const daemon&) = delete;\r
-\r
- ~daemon() = default;\r
-\r
- daemon& operator=(const daemon&) = delete;\r
-\r
- int run();\r
-\r
-private:\r
- bool threads_init();\r
- void threads_done();\r
-\r
- static void err_signal_handler(int _signo, siginfo_t* _signal_info, void* _ptr);\r
-\r
- struct sigaction m_sigact;\r
-\r
- main_thread m_main_thread;\r
-};\r
-\r
-}\r
-\r
-#endif /* __DAEMON_H__ */\r
#include <sys/file.h>
#include <sys/prctl.h>
#include <signal.h>
-#include <string.h>
+#include <string>
#include <unistd.h>
#include <execinfo.h>
#include <wait.h>
#include <errno.h>
#include <systemd/sd-journal.h>
#include <systemd/sd-daemon.h>
-
-#include "main_def.h"
+#include <iostream>
#include "main_thread.h"
#include "utils.h"
/*******************************************************/
/*******************************************************/
-static bool volatile g_running = true;
+static std::string g_device_name = "";
+static std::string g_device_model = "";
static main_thread g_main_thread;
+static bool volatile g_running = true;
+
/*******************************************************/
/*******************************************************/
static void kill_handler(int _sig);
/*******************************************************/
/*******************************************************/
-int main(int /*argc*/, char** /*argv*/)
+int main(int argc, char** argv)
{
struct sigaction act;
int ret;
+ if(argc < 3)
+ {
+ std::cout << "[NMDAEMON] please specify device name and model" << std::endl;
+ std::cout << "[NMDAEMON] stopped" << std::endl;
+ return 1;
+ }
+
+ g_device_name = std::string({argv[1]});
+ g_device_model = std::string({argv[2]});
+
+ if(argc != 4)
+ {
+ std::string curr_path = current_path();
+
+ std::cout << "[NMDAEMON] storage path not specified. default path is used - " << curr_path.c_str() << std::endl;
+
+ dat_file_path_name = curr_path + "/nmdaemon.dat";
+ cfg_file_path_name = curr_path + "/nmdaemon.cfg";
+ log_file_path_name = curr_path + "/nmdaemon.log";
+ }
+ else
+ {
+ std::string path{argv[3]};
+ dat_file_path_name = path + "/nmdaemon.dat";
+ cfg_file_path_name = path + "/nmdaemon.cfg";
+ log_file_path_name = path + "/nmdaemon.log";
+ }
+
// sd_journal_print(LOG_INFO, "[NMDAEMON] started");
write_log("[NMDAEMON] started\n");
/*******************************************************/
bool threads_init(void)
{
+ g_main_thread.set_device_name(g_device_name);
+ g_main_thread.set_device_model(g_device_model);
return g_main_thread.start();
}
void threads_done()
+++ /dev/null
-#ifndef __MAIN_DEF_H__
-#define __MAIN_DEF_H__
-
-/*******************************************************/
-/*******************************************************/
-#define PID_FILE_NAME "/var/run/nmdaemon.pid"
-#define DAT_FILE_NAME "/var/run/nmdaemon.dat"
-#define LOG_FILE_NAME "/var/log/nmdaemon.log"
-
-/*******************************************************/
-/*******************************************************/
-#define NMD_NEED_RESTART 1
-#define NMD_NEED_TERMINATE 2
-
-/*******************************************************/
-/*******************************************************/
-#define MAIN_THREAD_SLEEP_US 1000
-
-/*******************************************************/
-/*******************************************************/
-#define MAIN_THREAD_SOCKET_HOST "localhost"
-#define MAIN_THREAD_SOCKET_PORT 12345
-#define MAIN_THREAD_SOCKET_TIMEOUT_MS 100
-
-#endif /* __MAIN_DEF_H__ */
#include <fstream>
#include <string>
#include <memory>
-
-#include "main_def.h"
+#include <string.h>
#include "main_thread.h"
#include "rmi_thread.h"
-//#include "socket_base.h"
#include "utils.h"
#include "easysetup.h"
#include "ocpayload.h"
+#include "IOT_Device.h"
#include "IOT_Enrollee.h"
#include "IOT_Resource.h"
#include "IOT_AirconResource.h"
/*******************************************************/
/*******************************************************/
static const char* s_device_type = "oic.d.airconditioner";
-static const char* s_device_name = "IoTivity Simple Aircon";
-static const char* s_device_model = "Model ZZZ";
+//static const char* s_device_name = "IoTivity Simple Aircon";
+//static const char* s_device_model = "Model ZZZ";
/*******************************************************/
/*******************************************************/
-static FILE* server_fopen(const char *path, const char *mode)
+static FILE* server_fopen(const char* _path, const char* _mode)
{
- static const char CRED_FILE[] = "/var/run/oic_nmdaemon_db.dat";
- (void) path;
- return fopen(CRED_FILE, mode);
+ (void)_path;
+ return fopen(dat_file_path_name.c_str(), _mode);
}
/*******************************************************/
/*******************************************************/
-static std::string getDeviceID()
-{
- OCUUIdentity deviceId;
- OCStackResult res = OC::OCPlatform::getDeviceId(&deviceId);
- if (res != OC_STACK_OK)
- return std::string("");
-
- char s[128];
- unsigned char *id = deviceId.id;
- snprintf(s, sizeof(s), "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
- id[0], id[1], id[2], id[3],
- id[4], id[5], id[6], id[7],
- id[8], id[9], id[10], id[11],
- id[12], id[13], id[14], id[15]);
-
- return std::string(s);
-}
-
-/*******************************************************/
-/*******************************************************/
-main_thread::main_thread() : thread_base()
+main_thread::main_thread(std::string _device_name, std::string _device_model) :
+ thread_base(), m_device_name(_device_name), m_device_model(_device_model)
{
}
/*virtual*/ main_thread::~main_thread()
OCStringLL dt;
OCStringLL dm;
dt.value = (char*)s_device_type; dt.next = NULL;
- dm.value = (char*)s_device_model; dm.next = NULL;
- di.deviceName = (char*)s_device_name;
+// dm.value = (char*)s_device_model; dm.next = NULL;
+// di.deviceName = (char*)s_device_name;
+ dm.value = (char*)m_device_model.c_str(); dm.next = NULL;
+ di.deviceName = (char*)m_device_name.c_str();
di.types = &dt;
di.specVersion = NULL;
di.dataModelVersions = &dm;
if(OCPlatform::registerDeviceInfo(di) != OC_STACK_OK)
throw std::runtime_error("registerDeviceInfo failed");
- IOT_Enrollee* enr = nullptr;
+ IOT_Enrollee* enrollee = nullptr;
- std::string host, auth_provider, auth_code, uid, access_token;
- if(!rdat(host, auth_provider, auth_code, uid, access_token))
+ nmdaemon_config config;
+ if(!read_config(config))
{
- ESDeviceProperty dp = {{{WIFI_11G, WIFI_11N, WIFI_11AC, WiFi_EOF}, WIFI_5G}, {"IoTivity Simple Aircon", "Model ZZZ"}};
- enr = IOT_Enrollee::Create(dp, CT_ADAPTER_TCP);
- wdat(enr->host(), enr->auth_provider(), enr->auth_code(), enr->uid(), enr->access_token());
+// ESDeviceProperty dp = {{{WIFI_11G, WIFI_11N, WIFI_11AC, WiFi_EOF}, WIFI_5G}, {"IoTivity Simple Aircon", "Model ZZZ"}};
+ ESDeviceProperty dp = {{{WIFI_11G, WIFI_11N, WIFI_11AC, WiFi_EOF}, WIFI_5G}, {"", ""}};
+ if(m_device_name.size() < OIC_STRING_MAX_VALUE)
+ strcpy(dp.DevConf.deviceName, m_device_name.c_str());
+ if(m_device_model.size() < OIC_STRING_MAX_VALUE)
+ strcpy(dp.DevConf.modelNumber, m_device_model.c_str());
+ enrollee = IOT_Enrollee::Create(dp, CT_ADAPTER_TCP);
+ write_config({enrollee->host(), enrollee->auth_provider(), enrollee->auth_code(), enrollee->uid(), enrollee->access_token()});
}
else
{
- enr = IOT_Enrollee::Create(CT_ADAPTER_TCP, host, auth_provider, auth_code, uid, access_token);
+ enrollee = IOT_Enrollee::Create(CT_ADAPTER_TCP, config.host, config.auth_provider, config.auth_code, config.uid, config.access_token);
}
- std::string device_id = getDeviceID();
+ std::string device_id = IOT_Device::getDeviceId();
write_log( "[MAIN_THREADS] enrollee : \n\thost[%s] \n\tauth_provider[%s] \n\tauth_code[%s] \n\tuid[%s] \n\taccess_token[%s] \n\tdevice_id[%s]\n",
- enr->host().c_str(),
- enr->auth_provider().c_str(),
- enr->auth_code().c_str(),
- enr->uid().c_str(),
- enr->access_token().c_str(),
+ enrollee->host().c_str(),
+ enrollee->auth_provider().c_str(),
+ enrollee->auth_code().c_str(),
+ enrollee->uid().c_str(),
+ enrollee->access_token().c_str(),
device_id.c_str() );
+
+ std::string uri;
+ std::string rt;
+ std::string ri;
+
+ IOT_AirconResource aircon("/sec/aircon/0", {"x.com.samsung.da.device"}, {DEFAULT_INTERFACE, BATCH_INTERFACE, LINK_INTERFACE});
+ uri = aircon.getUri(); rt = aircon.getTypes()[0]; ri = aircon.getInterfaces()[0];
+ if(aircon.registerResource(uri, rt, ri, OC_DISCOVERABLE) != OC_STACK_OK)
+ throw std::runtime_error("registerResource failed");
+ ri = aircon.getInterfaces()[1]; aircon.bindInterface(ri);
+ ri = aircon.getInterfaces()[2]; aircon.bindInterface(ri);
+
+ IOT_PowerResource power("/power/0", {"oic.r.power"}, {DEFAULT_INTERFACE});
+ uri = power.getUri(); rt = power.getTypes()[0]; ri = power.getInterfaces()[0];
+ if(power.registerResource(uri, rt, ri, OC_OBSERVABLE) != OC_STACK_OK)
+ throw std::runtime_error("registerResource failed");
+
+ aircon.addChildResource(&power);
+
+ ResourceHandles rhandles;
+ if(aircon.publishResource(rhandles, enrollee->host(), CT_ADAPTER_TCP) != OC_STACK_OK)
+ throw std::runtime_error("publishResource failed");
+
+
std::shared_ptr<OC::OCResource> report_res = nullptr;
static const std::string report_name[] = {"name 1", "name 2", "name 3"};
static const std::string report_data[] = {"data 1", "data 2", "data 3"};
- // std::shared_ptr<OC::OCResource> policy_res = nullptr;
- // static const IOT_PolicyGroup policy_group[] = { {"tv-extension", {{"usb", "off", {}}, {"screen-capture", "on", {}}}},
- // {"tv-extension", {{"bluetooth", "on", {}}, {"iptables", "off", {"127.0.0.0/24|UDP|10-1024","1.1.1.1|TCP|80,443","8.8.8.8"}}}} };
-
- rmi_thread rmithread(enr->host(), device_id);
+ rmi_thread rmithread(enrollee->host(), device_id);
if(!rmithread.start())
throw std::runtime_error("publishResource failed");
std::this_thread::sleep_for(std::chrono::milliseconds(10000));
if(!report_res)
- report_res = IOT_Resource::findResource(enr->host(), {OC_RSRVD_WELL_KNOWN_URI}, static_cast<OCConnectivityType>(CT_DEFAULT), 1, "core.security");
+ report_res = IOT_Resource::findResource(enrollee->host(), {OC_RSRVD_WELL_KNOWN_URI}, static_cast<OCConnectivityType>(CT_DEFAULT), 1, "core.security");
if(report_res)
{
if(IOT_Resource::post(report_res, {"core.security"}, {DEFAULT_INTERFACE}, rpr, QueryParamsMap()) != OC_STACK_OK)
report_res = nullptr;
}
-
-
-// if(!policy_res)
-// policy_res = IOT_Resource::findResource(enr->host(), {OC_RSRVD_WELL_KNOWN_URI}, static_cast<OCConnectivityType>(CT_DEFAULT), 1, "core.policy");
-// if(policy_res)
-// {
-// int idx = std::rand() % 2;
-// OCRepresentation rpr;
-// rpr.setValue("policy", IOT_Policy::makePolicy({policy_group[idx]}));
-// QueryParamsMap qry{{"did", device_id}, {"agent", "AGENT_NUMBER_42"}};
-// if(IOT_Resource::post(policy_res, {"core.policy"}, {DEFAULT_INTERFACE}, rpr, qry) != OC_STACK_OK)
-// policy_res = nullptr;
-// }
-
}
rmithread.stop();
- delete enr;
+ delete enrollee;
}
catch(const std::exception& _e)
{
}
write_log("[MAIN_THREADS] stopped\n");
}
-
-/*******************************************************/
-/*******************************************************/
-bool main_thread::rdat(std::string& _host, std::string& _auth_provider, std::string& _auth_code, std::string& _uid, std::string& _access_token)
-{
- std::ifstream in(DAT_FILE_NAME);
- std::vector<std::string> v;
- std::string s;
- while(std::getline(in, s))
- v.push_back(s);
- in.close();
-
- if(v.size() == 5)
- {
- _host = v[0]; _auth_provider = v[1]; _auth_code = v[2]; _uid = v[3]; _access_token = v[4];
- return true;
- }
-
- return false;
-}
-void main_thread::wdat(const std::string& _host, const std::string& _auth_provider, const std::string& _auth_code, const std::string& _uid, const std::string& _access_token)
-{
- std::ofstream out(DAT_FILE_NAME, std::ofstream::out|std::ofstream::trunc);
- out << _host << std::endl << _auth_provider << std::endl << _auth_code << std::endl << _uid << std::endl << _access_token;
- out.close();
-}
class main_thread : public thread_base\r
{\r
public:\r
- main_thread();\r
+ main_thread(std::string _device_name = "", std::string _device_model = "");\r
+\r
+ void set_device_name(std::string _device_name)\r
+ {\r
+ m_device_name = _device_name;\r
+ }\r
+ void set_device_model(std::string _device_model)\r
+ {\r
+ m_device_model = _device_model;\r
+ }\r
\r
virtual ~main_thread();\r
\r
virtual void routine();\r
\r
private:\r
- bool rdat(std::string& _host, std::string& _auth_provider, std::string& _auth_code, std::string& _uid, std::string& _access_token);\r
- void wdat(const std::string& _host, const std::string& _auth_provider, const std::string& _auth_code, const std::string& _uid, const std::string& _access_token);\r
+ std::string m_device_name;\r
+ std::string m_device_model;\r
};\r
\r
}\r
+++ /dev/null
-#include <stdlib.h>
-#include <stdio.h>
-#include <signal.h>
-#include <unistd.h>
-#include <execinfo.h>
-#include <wait.h>
-#include <string.h>
-#include <errno.h>
-
-#include "main_def.h"
-
-#include "monitor.h"
-
-#include "daemon.h"
-#include "utils.h"
-
-using namespace NMD;
-
-/*******************************************************/
-/*******************************************************/
-/*static*/ int monitor::run()
-{
- bool start = true;
- int pid = -1;
- sigset_t sigset;
- siginfo_t siginfo;
- int status = 0;
-
- write_log("[MONITOR] started\n");
-
- sigemptyset(&sigset);
- sigaddset(&sigset, SIGQUIT);
- sigaddset(&sigset, SIGINT);
- sigaddset(&sigset, SIGTERM);
- sigaddset(&sigset, SIGCHLD);
- sigaddset(&sigset, SIGUSR1);
- sigprocmask(SIG_BLOCK, &sigset, NULL);
-
- save_pid();
-
- while(true)
- {
- if(start)
- {
- start = false;
- pid = fork();
- }
-
- if(pid == -1)
- {
- start = true;
- write_log("[MONITOR] fork() failed (%s)\n", strerror(errno));
- }
- else if(!pid)
- {
- daemon d;
- exit(d.run());
- }
- else
- {
- sigwaitinfo(&sigset, &siginfo);
-
- if(siginfo.si_signo == SIGCHLD)
- {
- wait(&status);
- status = WEXITSTATUS(status);
-
- if(status == NMD_NEED_RESTART)
- {
- start = true;
- write_log("[MONITOR] child will be restarted\n");
- }
- else if(status == NMD_NEED_TERMINATE)
- {
- write_log("[MONITOR] child stopped\n");
- break;
- }
- }
- else if(siginfo.si_signo == SIGUSR1)
- {
- write_log("[MONITOR] signal %s\n", strsignal(siginfo.si_signo));
- kill(pid, SIGUSR1);
- }
- else
- {
- status = 0;
- write_log("[MONITOR] signal %s\n", strsignal(siginfo.si_signo));
- kill(pid, SIGTERM);
- break;
- }
- }
- }
-
- unlink(PID_FILE_NAME);
-
- write_log("[MONITOR] stopped\n");
-
- return status;
-}
-
-/*******************************************************/
-/*******************************************************/
-/*static*/ void monitor::save_pid()
-{
- FILE* file = fopen(PID_FILE_NAME, "w+");
- if(file)
- {
- fprintf(file, "%u", getpid());
- fclose(file);
- }
-}
+++ /dev/null
-#ifndef __MONITOR_H__
-#define __MONITOR_H__
-
-namespace NMD
-{
-
-/*******************************************************/
-/*******************************************************/
-class monitor final
-{
-public:
- monitor() = default;
- monitor(const monitor&) = delete;
-
- ~monitor() = default;
-
- monitor& operator=(const monitor&) = delete;
-
- static int run();
-
-private:
- static void save_pid();
-};
-
-}
-
-#endif /* __MONITOR_H__ */
#include <string>
#include <memory>
-#include "main_def.h"
-
#include "rmi_thread.h"
#include "utils.h"
+++ /dev/null
-#include <stdlib.h>\r
-#include <unistd.h>\r
-#include <sys/types.h>\r
-#include <sys/socket.h>\r
-#include <netinet/in.h>\r
-#include <netinet/ip.h>\r
-#include <netdb.h>\r
-#include <sys/un.h>\r
-#include <sys/select.h>\r
-#include <fcntl.h>\r
-#include <sys/time.h>\r
-\r
-#include "socket_base.h"\r
-\r
-using namespace NMD;\r
-\r
-/*******************************************************/\r
-/*******************************************************/\r
-socket_base::socket_base(bool _non_block /*= false*/) : m_socket_fd(0)\r
-{\r
- m_socket_fd = socket(AF_INET, SOCK_STREAM, 0);\r
- if(_non_block)\r
- fcntl(m_socket_fd, F_SETFL, O_NONBLOCK);\r
-}\r
-socket_base::socket_base(const socket_base &_obj) : m_socket_fd(_obj.m_socket_fd)\r
-{\r
-}\r
-\r
-/*******************************************************/\r
-/*******************************************************/\r
-/*virtual*/ socket_base::~socket_base()\r
-{\r
- close(m_socket_fd);\r
-}\r
-\r
-/*******************************************************/\r
-/*******************************************************/\r
-/*virtual*/ socket_base& socket_base::operator=(const socket_base& _obj)\r
-{\r
- if(this != &_obj)\r
- {\r
- m_socket_fd = _obj.m_socket_fd;\r
- }\r
- return *this;\r
-}\r
-\r
-/*******************************************************/\r
-/*******************************************************/\r
-/*virtual*/ bool socket_base::bind(const char* _host, int _port)\r
-{\r
- struct sockaddr_in info;\r
- if(!socket_info(&info, _host, _port))\r
- return false;\r
- return (::bind(m_socket_fd, (struct sockaddr*)&info, sizeof(info)) < 0) ? false : true;\r
-}\r
-/*virtual*/ bool socket_base::listen()\r
-{\r
- return (::listen(m_socket_fd, m_connections) < 0) ? false : true;\r
-}\r
-/*virtual*/ int socket_base::accept(int _wait_timeout_ms)\r
-{\r
- fd_set rset;\r
- struct timeval timeout;\r
- int res = -1;\r
-\r
- FD_ZERO(&rset);\r
- FD_SET(m_socket_fd, &rset);\r
-\r
- timeout.tv_sec = 0;\r
- timeout.tv_usec = _wait_timeout_ms * 1000 + 1;\r
-\r
- if(::select(m_socket_fd + 1, &rset, NULL, NULL, &timeout) > 0)\r
- {\r
- if( FD_ISSET(m_socket_fd, &rset) )\r
- {\r
- struct sockaddr_in info;\r
- socklen_t ilen = sizeof(info);\r
- res = ::accept(m_socket_fd, (struct sockaddr*)&info, &ilen);\r
- }\r
- }\r
-\r
- return res;\r
-}\r
-\r
-/*******************************************************/\r
-/*******************************************************/\r
-/*virtual*/ bool socket_base::connect(const char* _host, int _port)\r
-{\r
- struct sockaddr_in info;\r
- if(!socket_info(&info, _host, _port))\r
- return false;\r
- return (::connect(m_socket_fd, (struct sockaddr*)&info, sizeof(info)) < 0) ? false : true;\r
-}\r
-\r
-/*******************************************************/\r
-/*******************************************************/\r
-/*virtual*/ bool socket_base::write(const void* _data, int _size)\r
-{\r
- return write(m_socket_fd, _data, _size);\r
-}\r
-/*virtual*/ int socket_base::read(void* _buff, int _size)\r
-{\r
- return read(m_socket_fd, _buff, _size);\r
-}\r
-\r
-/*******************************************************/\r
-/*******************************************************/\r
-/*static*/ bool socket_base::write(int _socket, const void* _data, int _size)\r
-{\r
- return (::write(_socket, _data, _size) == _size);\r
-}\r
-/*static*/ int socket_base::read(int _socket, void* _buff, int _size)\r
-{\r
- return (int)::read(_socket, _buff, _size);\r
-}\r
-\r
-/*******************************************************/\r
-/*******************************************************/\r
-/*static*/ void socket_base::close(int _socket)\r
-{\r
- ::close(_socket);\r
-}\r
-\r
-/*******************************************************/\r
-/*******************************************************/\r
-/*static*/ bool socket_base::socket_info(struct sockaddr_in* _info, const char* _host, int _port)\r
-{\r
- struct in_addr addr;\r
- int port;\r
-\r
- {\r
- struct hostent* lhi = (struct hostent*)gethostbyname(_host);\r
- if( (lhi == NULL) || (lhi->h_length == 0) )\r
- return false;\r
-\r
- addr.s_addr = *( (int*)(lhi->h_addr_list[0]) );\r
- }\r
-\r
- port = (int)htons(_port);\r
-\r
- memset(_info, 0, sizeof(struct sockaddr_in));\r
- _info->sin_family = AF_INET;\r
- _info->sin_addr = addr;\r
- _info->sin_port = port;\r
-\r
- return true;\r
-}\r
+++ /dev/null
-#ifndef __SOCKET_BASE_H__\r
-#define __SOCKET_BASE_H__\r
-\r
-namespace NMD\r
-{\r
-\r
-/*******************************************************/\r
-/*******************************************************/\r
-class socket_base\r
-{\r
-public:\r
- socket_base(bool _non_block = false);\r
- socket_base(const socket_base& _obj);\r
-\r
- virtual ~socket_base();\r
-\r
- virtual socket_base& operator=(const socket_base& _obj);\r
-\r
- virtual bool bind(const char* _host, int _port);\r
- virtual bool listen();\r
- virtual int accept(int _wait_timeout_ms);\r
-\r
- virtual bool connect(const char* _host, int _port);\r
-\r
- virtual bool write(const void* _data, int _size);\r
- virtual int read(void* _buff, int _size);\r
-\r
- static bool write(int _socket, const void* _data, int _size);\r
- static int read(int _socket, void* _buff, int _size);\r
-\r
- static void close(int _socket);\r
-\r
- static bool socket_info(struct sockaddr_in* _info, const char* _host, int _port);\r
-\r
-protected:\r
- int m_socket_fd;\r
-\r
-private:\r
- static const int m_connections = 5;\r
-};\r
-\r
-}\r
-\r
-#endif /* __SOCKET_BASE_H__ */\r
#include <stdlib.h>\r
#include <stdarg.h>\r
#include <stdio.h>\r
-\r
-#include "main_def.h"\r
+#include <limits.h>\r
+#include <string>\r
+#include <unistd.h>\r
+#include <iostream>\r
+#include <fstream>\r
+#include <vector>\r
\r
#include "utils.h"\r
\r
\r
/*******************************************************/\r
/*******************************************************/\r
+std::string dat_file_path_name = "";\r
+std::string cfg_file_path_name = "";\r
+std::string log_file_path_name = "";\r
+\r
+/*******************************************************/\r
+/*******************************************************/\r
static bool wl(const char* _msg, va_list _vl);\r
\r
/*******************************************************/\r
/*******************************************************/\r
+std::string current_path(void)\r
+{\r
+ char buff[PATH_MAX];\r
+ ssize_t cnt = readlink("/proc/self/exe", buff, PATH_MAX);\r
+ if(cnt == 0)\r
+ return std::string();\r
+\r
+ std::string path{buff};\r
+ std::string::size_type pos = path.find_last_of("\\/");\r
+ return path.substr(0, pos);\r
+}\r
+\r
+/*******************************************************/\r
+/*******************************************************/\r
+bool read_config(nmdaemon_config& _config)\r
+{\r
+ std::ifstream in(cfg_file_path_name.c_str());\r
+ std::vector<std::string> v;\r
+ std::string s;\r
+ while(std::getline(in, s))\r
+ v.push_back(s);\r
+ in.close();\r
+\r
+ if(v.size() != 5)\r
+ return false;\r
+\r
+ _config.host = v[0]; _config.auth_provider = v[1]; _config.auth_code = v[2]; _config.uid = v[3]; _config.access_token = v[4];\r
+\r
+ return true;\r
+}\r
+void write_config(const nmdaemon_config& _config)\r
+{\r
+ std::ofstream out(cfg_file_path_name.c_str(), std::ofstream::out|std::ofstream::trunc);\r
+ out << _config.host << std::endl << _config.auth_provider << std::endl << _config.auth_code << std::endl << _config.uid << std::endl << _config.access_token;\r
+ out.close();\r
+}\r
+\r
+/*******************************************************/\r
+/*******************************************************/\r
bool write_log(const char* _msg, ...)\r
{\r
bool res = false;\r
{\r
bool res = false;\r
\r
- FILE* file = fopen(LOG_FILE_NAME, "a+");\r
+ FILE* file = fopen(log_file_path_name.c_str(), "a+");\r
if(file)\r
{\r
res = (bool)vfprintf(file, _msg, _vl);\r
#ifndef __UTILS_H__\r
#define __UTILS_H__\r
\r
+#include <string>\r
+\r
namespace NMD\r
{\r
+/*******************************************************/\r
+/*******************************************************/\r
+extern std::string dat_file_path_name;\r
+extern std::string cfg_file_path_name;\r
+extern std::string log_file_path_name;\r
\r
/*******************************************************/\r
/*******************************************************/\r
-bool write_log(const char* _msg, ...);\r
+std::string current_path(void);\r
\r
+typedef struct\r
+{\r
+ std::string host;\r
+ std::string auth_provider;\r
+ std::string auth_code;\r
+ std::string uid;\r
+ std::string access_token;\r
+} nmdaemon_config;\r
+\r
+bool read_config(nmdaemon_config& _config);\r
+void write_config(const nmdaemon_config& _config);\r
+\r
+bool write_log(const char* _msg, ...);\r
}\r
\r
#endif /* __UTILS_H__ */\r
throw runtime_error("Failed to find policy resource");
string device_id = IOT_Device::getDeviceId();
- string agent_id = "AGENT_NUMBER_42";
+ string agent_id = /*"AGENT_NUMBER_42"*/"3574462a-7efa-9449-4d9f-488734c79c0a";
IOT_PolicyItem item1("usb", "off", {});
IOT_PolicyItem item2("screen-capture", "on", {});
IOT_PolicyGroup group("tv-extension", {item1, item2});
if(IOT_Resource::post(policy_res, {"core.policy"}, {DEFAULT_INTERFACE}, rep, QueryParamsMap({{"did", device_id}, {"agent", agent_id}})) != OC_STACK_OK)
throw runtime_error("Failed to post policy");
- cvar.wait_for(lck, chrono::seconds(1));
+ cvar.wait_for(lck, chrono::seconds(3));
} );
ASSERT_TRUE(res);
}
projects / platform / core / security / suspicious-activity-monitor.git / commitdiff