486 lines
13 KiB
C++
486 lines
13 KiB
C++
/*************************************************************************
|
||
> File Name : OperateNos.h
|
||
> Author : TL Song
|
||
> EMail : songtianlun@frytea.com
|
||
> Created Time : Thu 03 Dec 2020 09:13:48 AM CST
|
||
************************************************************************/
|
||
|
||
#include <stdio.h>
|
||
#include <iostream>
|
||
#include <ctype.h>
|
||
#include <string.h>
|
||
#include <zmq.h>
|
||
#include <unistd.h>
|
||
|
||
#define ZMQ_PUBLIC_KEY_1 "@M[-VQ%R2MKguD/h/0w7.fNq%GGjV!1Q:bVeu*u>"
|
||
#define ZMQ_PRIVATE_KEY_1 "S*{[[V$7f<(jA<XWT?&baG>p^]M>I!n?dN]SXgB]"
|
||
|
||
#define WEB_EXEC_FAILED 201
|
||
#define WEB_EXEC_SUCCES 202
|
||
|
||
typedef enum Web_Op_E
|
||
{
|
||
NOS_POWER_ON=1,
|
||
NOS_POWER_OFF,
|
||
NOS_RESTART
|
||
}Web_Op_T;
|
||
|
||
typedef struct Web_Msg_S
|
||
{
|
||
unsigned int nos_id;
|
||
Web_Op_T nos_op;
|
||
unsigned int result; //0:defaule 201:failed 202:succeed
|
||
}Web_Msg_T;
|
||
|
||
// INIReader.h https://github.com/jtilly/inih
|
||
#ifndef __INI_H__
|
||
#define __INI_H__
|
||
|
||
#ifdef __cplusplus
|
||
extern "C" {
|
||
#endif
|
||
|
||
typedef int (*ini_handler)(void* user, const char* section,
|
||
const char* name, const char* value);
|
||
typedef char* (*ini_reader)(char* str, int num, void* stream);
|
||
int ini_parse(const char* filename, ini_handler handler, void* user);
|
||
int ini_parse_file(FILE* file, ini_handler handler, void* user);
|
||
int ini_parse_stream(ini_reader reader, void* stream, ini_handler handler,
|
||
void* user);
|
||
#ifndef INI_ALLOW_MULTILINE
|
||
#define INI_ALLOW_MULTILINE 1
|
||
#endif
|
||
|
||
#ifndef INI_ALLOW_BOM
|
||
#define INI_ALLOW_BOM 1
|
||
#endif
|
||
|
||
#ifndef INI_ALLOW_INLINE_COMMENTS
|
||
#define INI_ALLOW_INLINE_COMMENTS 1
|
||
#endif
|
||
#ifndef INI_INLINE_COMMENT_PREFIXES
|
||
#define INI_INLINE_COMMENT_PREFIXES ";"
|
||
#endif
|
||
|
||
/* Nonzero to use stack, zero to use heap (malloc/free). */
|
||
#ifndef INI_USE_STACK
|
||
#define INI_USE_STACK 1
|
||
#endif
|
||
|
||
/* Stop parsing on first error (default is to keep parsing). */
|
||
#ifndef INI_STOP_ON_FIRST_ERROR
|
||
#define INI_STOP_ON_FIRST_ERROR 0
|
||
#endif
|
||
|
||
/* Maximum line length for any line in INI file. */
|
||
#ifndef INI_MAX_LINE
|
||
#define INI_MAX_LINE 200
|
||
#endif
|
||
|
||
#ifdef __cplusplus
|
||
}
|
||
#endif
|
||
|
||
#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)
|
||
#define _CRT_SECURE_NO_WARNINGS
|
||
#endif
|
||
|
||
#if !INI_USE_STACK
|
||
#include <stdlib.h>
|
||
#endif
|
||
|
||
#define MAX_SECTION 50
|
||
#define MAX_NAME 50
|
||
|
||
/* Strip whitespace chars off end of given string, in place. Return s. */
|
||
inline static char* rstrip(char* s)
|
||
{
|
||
char* p = s + strlen(s);
|
||
while (p > s && isspace((unsigned char)(*--p)))
|
||
*p = '\0';
|
||
return s;
|
||
}
|
||
|
||
/* Return pointer to first non-whitespace char in given string. */
|
||
inline static char* lskip(const char* s)
|
||
{
|
||
while (*s && isspace((unsigned char)(*s)))
|
||
s++;
|
||
return (char*)s;
|
||
}
|
||
|
||
/* Return pointer to first char (of chars) or inline comment in given string,
|
||
or pointer to null at end of string if neither found. Inline comment must
|
||
be prefixed by a whitespace character to register as a comment. */
|
||
inline static char* find_chars_or_comment(const char* s, const char* chars)
|
||
{
|
||
#if INI_ALLOW_INLINE_COMMENTS
|
||
int was_space = 0;
|
||
while (*s && (!chars || !strchr(chars, *s)) &&
|
||
!(was_space && strchr(INI_INLINE_COMMENT_PREFIXES, *s))) {
|
||
was_space = isspace((unsigned char)(*s));
|
||
s++;
|
||
}
|
||
#else
|
||
while (*s && (!chars || !strchr(chars, *s))) {
|
||
s++;
|
||
}
|
||
#endif
|
||
return (char*)s;
|
||
}
|
||
|
||
/* Version of strncpy that ensures dest (size bytes) is null-terminated. */
|
||
inline static char* strncpy0(char* dest, const char* src, size_t size)
|
||
{
|
||
strncpy(dest, src, size);
|
||
dest[size - 1] = '\0';
|
||
return dest;
|
||
}
|
||
|
||
/* See documentation in header file. */
|
||
inline int ini_parse_stream(ini_reader reader, void* stream, ini_handler handler,
|
||
void* user)
|
||
{
|
||
/* Uses a fair bit of stack (use heap instead if you need to) */
|
||
#if INI_USE_STACK
|
||
char line[INI_MAX_LINE];
|
||
#else
|
||
char* line;
|
||
#endif
|
||
char section[MAX_SECTION] = "";
|
||
char prev_name[MAX_NAME] = "";
|
||
|
||
char* start;
|
||
char* end;
|
||
char* name;
|
||
char* value;
|
||
int lineno = 0;
|
||
int error = 0;
|
||
|
||
#if !INI_USE_STACK
|
||
line = (char*)malloc(INI_MAX_LINE);
|
||
if (!line) {
|
||
return -2;
|
||
}
|
||
#endif
|
||
|
||
/* Scan through stream line by line */
|
||
while (reader(line, INI_MAX_LINE, stream) != NULL) {
|
||
lineno++;
|
||
|
||
start = line;
|
||
#if INI_ALLOW_BOM
|
||
if (lineno == 1 && (unsigned char)start[0] == 0xEF &&
|
||
(unsigned char)start[1] == 0xBB &&
|
||
(unsigned char)start[2] == 0xBF) {
|
||
start += 3;
|
||
}
|
||
#endif
|
||
start = lskip(rstrip(start));
|
||
|
||
if (*start == ';' || *start == '#') {
|
||
/* Per Python configparser, allow both ; and # comments at the
|
||
start of a line */
|
||
}
|
||
#if INI_ALLOW_MULTILINE
|
||
else if (*prev_name && *start && start > line) {
|
||
|
||
#if INI_ALLOW_INLINE_COMMENTS
|
||
end = find_chars_or_comment(start, NULL);
|
||
if (*end)
|
||
*end = '\0';
|
||
rstrip(start);
|
||
#endif
|
||
|
||
/* Non-blank line with leading whitespace, treat as continuation
|
||
of previous name's value (as per Python configparser). */
|
||
if (!handler(user, section, prev_name, start) && !error)
|
||
error = lineno;
|
||
}
|
||
#endif
|
||
else if (*start == '[') {
|
||
/* A "[section]" line */
|
||
end = find_chars_or_comment(start + 1, "]");
|
||
if (*end == ']') {
|
||
*end = '\0';
|
||
strncpy0(section, start + 1, sizeof(section));
|
||
*prev_name = '\0';
|
||
}
|
||
else if (!error) {
|
||
/* No ']' found on section line */
|
||
error = lineno;
|
||
}
|
||
}
|
||
else if (*start) {
|
||
/* Not a comment, must be a name[=:]value pair */
|
||
end = find_chars_or_comment(start, "=:");
|
||
if (*end == '=' || *end == ':') {
|
||
*end = '\0';
|
||
name = rstrip(start);
|
||
value = lskip(end + 1);
|
||
#if INI_ALLOW_INLINE_COMMENTS
|
||
end = find_chars_or_comment(value, NULL);
|
||
if (*end)
|
||
*end = '\0';
|
||
#endif
|
||
rstrip(value);
|
||
|
||
/* Valid name[=:]value pair found, call handler */
|
||
strncpy0(prev_name, name, sizeof(prev_name));
|
||
if (!handler(user, section, name, value) && !error)
|
||
error = lineno;
|
||
}
|
||
else if (!error) {
|
||
/* No '=' or ':' found on name[=:]value line */
|
||
error = lineno;
|
||
}
|
||
}
|
||
|
||
#if INI_STOP_ON_FIRST_ERROR
|
||
if (error)
|
||
break;
|
||
#endif
|
||
}
|
||
|
||
#if !INI_USE_STACK
|
||
free(line);
|
||
#endif
|
||
|
||
return error;
|
||
}
|
||
|
||
/* See documentation in header file. */
|
||
inline int ini_parse_file(FILE* file, ini_handler handler, void* user)
|
||
{
|
||
return ini_parse_stream((ini_reader)fgets, file, handler, user);
|
||
}
|
||
|
||
/* See documentation in header file. */
|
||
inline int ini_parse(const char* filename, ini_handler handler, void* user)
|
||
{
|
||
FILE* file;
|
||
int error;
|
||
|
||
file = fopen(filename, "r");
|
||
if (!file)
|
||
return -1;
|
||
error = ini_parse_file(file, handler, user);
|
||
fclose(file);
|
||
return error;
|
||
}
|
||
|
||
#endif /* __INI_H__ */
|
||
|
||
|
||
#ifndef __INIREADER_H__
|
||
#define __INIREADER_H__
|
||
|
||
#include <map>
|
||
#include <set>
|
||
#include <string>
|
||
|
||
// Read an INI file into easy-to-access name/value pairs. (Note that I've gone
|
||
// for simplicity here rather than speed, but it should be pretty decent.)
|
||
class INIReader
|
||
{
|
||
public:
|
||
// Empty Constructor
|
||
INIReader() {};
|
||
|
||
// Construct INIReader and parse given filename. See ini.h for more info
|
||
// about the parsing.
|
||
INIReader(std::string filename);
|
||
|
||
// Construct INIReader and parse given file. See ini.h for more info
|
||
// about the parsing.
|
||
INIReader(FILE *file);
|
||
|
||
// Return the result of ini_parse(), i.e., 0 on success, line number of
|
||
// first error on parse error, or -1 on file open error.
|
||
int ParseError() const;
|
||
|
||
// Return the list of sections found in ini file
|
||
const std::set<std::string>& Sections() const;
|
||
|
||
// Get a string value from INI file, returning default_value if not found.
|
||
std::string Get(std::string section, std::string name,
|
||
std::string default_value) const;
|
||
|
||
// Get an integer (long) value from INI file, returning default_value if
|
||
// not found or not a valid integer (decimal "1234", "-1234", or hex "0x4d2").
|
||
long GetInteger(std::string section, std::string name, long default_value) const;
|
||
|
||
// Get a real (floating point double) value from INI file, returning
|
||
// default_value if not found or not a valid floating point value
|
||
// according to strtod().
|
||
double GetReal(std::string section, std::string name, double default_value) const;
|
||
|
||
// Get a single precision floating point number value from INI file, returning
|
||
// default_value if not found or not a valid floating point value
|
||
// according to strtof().
|
||
float GetFloat(std::string section, std::string name, float default_value) const;
|
||
|
||
// Get a boolean value from INI file, returning default_value if not found or if
|
||
// not a valid true/false value. Valid true values are "true", "yes", "on", "1",
|
||
// and valid false values are "false", "no", "off", "0" (not case sensitive).
|
||
bool GetBoolean(std::string section, std::string name, bool default_value) const;
|
||
|
||
protected:
|
||
int _error;
|
||
std::map<std::string, std::string> _values;
|
||
std::set<std::string> _sections;
|
||
static std::string MakeKey(std::string section, std::string name);
|
||
static int ValueHandler(void* user, const char* section, const char* name,
|
||
const char* value);
|
||
};
|
||
|
||
#endif // __INIREADER_H__
|
||
|
||
|
||
#ifndef __INIREADER__
|
||
#define __INIREADER__
|
||
|
||
#include <algorithm>
|
||
#include <cctype>
|
||
#include <cstdlib>
|
||
|
||
inline INIReader::INIReader(std::string filename)
|
||
{
|
||
_error = ini_parse(filename.c_str(), ValueHandler, this);
|
||
}
|
||
|
||
inline INIReader::INIReader(FILE *file)
|
||
{
|
||
_error = ini_parse_file(file, ValueHandler, this);
|
||
}
|
||
|
||
inline int INIReader::ParseError() const
|
||
{
|
||
return _error;
|
||
}
|
||
|
||
inline const std::set<std::string>& INIReader::Sections() const
|
||
{
|
||
return _sections;
|
||
}
|
||
|
||
inline std::string INIReader::Get(std::string section, std::string name, std::string default_value) const
|
||
{
|
||
std::string key = MakeKey(section, name);
|
||
return _values.count(key) ? _values.at(key) : default_value;
|
||
}
|
||
|
||
inline long INIReader::GetInteger(std::string section, std::string name, long default_value) const
|
||
{
|
||
std::string valstr = Get(section, name, "");
|
||
const char* value = valstr.c_str();
|
||
char* end;
|
||
// This parses "1234" (decimal) and also "0x4D2" (hex)
|
||
long n = strtol(value, &end, 0);
|
||
return end > value ? n : default_value;
|
||
}
|
||
|
||
inline double INIReader::GetReal(std::string section, std::string name, double default_value) const
|
||
{
|
||
std::string valstr = Get(section, name, "");
|
||
const char* value = valstr.c_str();
|
||
char* end;
|
||
double n = strtod(value, &end);
|
||
return end > value ? n : default_value;
|
||
}
|
||
|
||
inline float INIReader::GetFloat(std::string section, std::string name, float default_value) const
|
||
{
|
||
std::string valstr = Get(section, name, "");
|
||
const char* value = valstr.c_str();
|
||
char* end;
|
||
float n = strtof(value, &end);
|
||
return end > value ? n : default_value;
|
||
}
|
||
|
||
inline bool INIReader::GetBoolean(std::string section, std::string name, bool default_value) const
|
||
{
|
||
std::string valstr = Get(section, name, "");
|
||
// Convert to lower case to make string comparisons case-insensitive
|
||
std::transform(valstr.begin(), valstr.end(), valstr.begin(), ::tolower);
|
||
if (valstr == "true" || valstr == "yes" || valstr == "on" || valstr == "1")
|
||
return true;
|
||
else if (valstr == "false" || valstr == "no" || valstr == "off" || valstr == "0")
|
||
return false;
|
||
else
|
||
return default_value;
|
||
}
|
||
|
||
inline std::string INIReader::MakeKey(std::string section, std::string name)
|
||
{
|
||
std::string key = section + "=" + name;
|
||
// Convert to lower case to make section/name lookups case-insensitive
|
||
std::transform(key.begin(), key.end(), key.begin(), ::tolower);
|
||
return key;
|
||
}
|
||
|
||
inline int INIReader::ValueHandler(void* user, const char* section, const char* name,
|
||
const char* value)
|
||
{
|
||
INIReader* reader = (INIReader*)user;
|
||
std::string key = MakeKey(section, name);
|
||
if (reader->_values[key].size() > 0)
|
||
reader->_values[key] += "\n";
|
||
reader->_values[key] += value;
|
||
reader->_sections.insert(section);
|
||
return 1;
|
||
}
|
||
#endif // __INIREADER__
|
||
|
||
|
||
// 单实例模板类 饿汉模式
|
||
#ifndef __SINGLETON_CLASS_H__
|
||
#define __SINGLETON_CLASS_H__
|
||
template <typename T>
|
||
class singleton
|
||
{
|
||
private:
|
||
static T* p; //标志指针
|
||
|
||
public:
|
||
static T* instance(); //得到类型为T对象的方法
|
||
};
|
||
|
||
template <typename T>
|
||
T* singleton<T>::p = new T(); //不管外部是否要使用对象，进入main函数前就生成T对象，p指向该对象的地址
|
||
|
||
template <typename T>
|
||
T* singleton<T>::instance()
|
||
{
|
||
return p;
|
||
}
|
||
#endif /* __SINGLETON_CLASS_H__ */
|
||
|
||
#ifndef FOPERATENOS_H
|
||
#define FOPERATENOS_H
|
||
class FOperateNos
|
||
{
|
||
public:
|
||
FOperateNos(){};
|
||
virtual ~FOperateNos(){
|
||
DestroySocket();
|
||
};
|
||
|
||
public:
|
||
void Init();
|
||
int StartNos(int iNosIdx);
|
||
int StopNos(int iNosIdx);
|
||
int RestartNos(int iNosIdx);
|
||
|
||
private:
|
||
void InitSocket();
|
||
void DestroySocket();
|
||
int SendCmdToShd(void * sMsg, int iMsgLen);
|
||
friend class singleton<FOperateNos>;
|
||
|
||
private:
|
||
void * ctx;
|
||
void *sock;
|
||
INIReader reader;
|
||
};
|
||
#endif /* FOPERATENOS_H */ |