951 lines
24 KiB
C++
951 lines
24 KiB
C++
/*************************************************************************
|
||
*
|
||
* DeepCam CONFIDENTIAL
|
||
* FILE: face-detector-tracker.py
|
||
*
|
||
* [2016] - [2017] DeepCam, LLC and DeepCam
|
||
|
||
NOTICE:
|
||
* All information contained herein is, and remains the property of DeepCam LLC.
|
||
* The intellectual and technical concepts contained herein are proprietary to DeepCam
|
||
* and may be covered by U.S. and Foreign Patents,patents in process, and are protected by
|
||
* trade secret or copyright law.
|
||
* Dissemination of this information or reproduction of this material
|
||
* is strictly forbidden unless prior written permission is obtained
|
||
* DeepCam, LLC.
|
||
*
|
||
*
|
||
* Written: Delong Qi
|
||
* Date: 08/11/2017
|
||
* Mail: delong.qi@deepcam.com
|
||
*/
|
||
|
||
#include "Request.h"
|
||
#include "openssl\aes.h"
|
||
#include "openssl\rand.h"
|
||
#include <algorithm>
|
||
#include <io.h>
|
||
#include <sstream>
|
||
using namespace std;
|
||
|
||
/*
|
||
//获取当前时间的字符串，格式固定，用于做上传到服务器的参数，格式："%04d-%02d-%02d %02d:%02d:%02d.%d"
|
||
int _getTimestampFormatString(char * strTime)
|
||
{
|
||
SYSTEMTIME wtm;
|
||
GetLocalTime(&wtm);
|
||
if (strTime)
|
||
{
|
||
sprintf_s(strTime, 128, "%04d-%02d-%02d %02d:%02d:%02d.%03d", wtm.wYear, wtm.wMonth, wtm.wDay, wtm.wHour, wtm.wMinute, wtm.wSecond, wtm.wMilliseconds);
|
||
}
|
||
return (wtm.wSecond * 1000 + wtm.wMilliseconds);
|
||
}
|
||
//获取当前时间的字符串，格式自定义，用于做文件名或其它用途。
|
||
int _getTimeString(char * strTime)
|
||
{
|
||
SYSTEMTIME wtm;
|
||
GetLocalTime(&wtm);
|
||
if (strTime)
|
||
{
|
||
sprintf_s(strTime, 128, "%04d-%02d-%02d_%02d-%02d-%02d-%03d", wtm.wYear, wtm.wMonth, wtm.wDay, wtm.wHour, wtm.wMinute, wtm.wSecond, wtm.wMilliseconds);
|
||
}
|
||
return (wtm.wSecond * 1000 + wtm.wMilliseconds);
|
||
}
|
||
*/
|
||
|
||
|
||
#pragma region AES_IMPL
|
||
#define AES128_KEYLEN 16 //128 Bits
|
||
#define AES192_KEYLEN 24 //192 Bits
|
||
#define AES256_KEYLEN 32 //256 Bits
|
||
//加密普通文本字串，加密后返回加密二进制的十六进制字串。
|
||
|
||
bool Encrypt_AES_CBC(string & key, string & srcData, string & encryptData)
|
||
{
|
||
int keyLen = key.length();
|
||
int aesKeyLen = keyLen;
|
||
if (keyLen > AES192_KEYLEN)
|
||
{
|
||
aesKeyLen = AES256_KEYLEN;
|
||
}
|
||
else if (keyLen > AES128_KEYLEN && keyLen <= AES192_KEYLEN)
|
||
{
|
||
aesKeyLen = AES192_KEYLEN;
|
||
}
|
||
else if (keyLen > 0 && keyLen <= AES128_KEYLEN)
|
||
{
|
||
aesKeyLen = AES128_KEYLEN;
|
||
}
|
||
else
|
||
{
|
||
//LOGGER_ERROR("Input key length is error .");
|
||
printf("Input key length is error .\n");
|
||
return false;
|
||
}
|
||
|
||
if (srcData.length() < 1)
|
||
{
|
||
//LOGGER_ERROR("Input lenth error - SrcData:" << srcData.c_str());
|
||
printf("Input lenth error ...\n");
|
||
return false;
|
||
}
|
||
|
||
char tempKey[AES256_KEYLEN + 1] = {0};
|
||
strncpy_s(tempKey, AES256_KEYLEN + 1, key.c_str(), keyLen);
|
||
tempKey[keyLen] = '\0';
|
||
char IV[AES_BLOCK_SIZE + 1] = { 0 };
|
||
strncpy_s(IV, AES_BLOCK_SIZE + 1, tempKey, AES_BLOCK_SIZE);
|
||
|
||
int dataLen = ((srcData.length() + AES_BLOCK_SIZE - 1) / AES_BLOCK_SIZE)*AES_BLOCK_SIZE;
|
||
|
||
vector<char> tempSrcData;
|
||
vector<char> tempEncryptData;
|
||
AES_KEY AesKey;
|
||
|
||
tempSrcData.resize(dataLen+1, '\0');
|
||
tempEncryptData.resize(dataLen+1, '\0');
|
||
strcpy_s(tempSrcData.data(), dataLen+1, srcData.c_str());
|
||
|
||
//set encryption key
|
||
if (AES_set_encrypt_key((const unsigned char *)tempKey, aesKeyLen*8, &AesKey)<0)
|
||
{
|
||
//LOGGER_ERROR("Unable to set encryption key in AES...");
|
||
printf("Unable to set encryption key in AES...\n");
|
||
return false;
|
||
}
|
||
//encryption
|
||
AES_cbc_encrypt((const unsigned char *)tempSrcData.data(), (unsigned char *)tempEncryptData.data(), dataLen, &AesKey, (unsigned char *)IV, AES_ENCRYPT);
|
||
encryptData = string("");
|
||
for (int i = 0; i < dataLen; i++)
|
||
{
|
||
char tempBuf[3] = { 0 };
|
||
sprintf_s(tempBuf, 3, "%02x",(BYTE)tempEncryptData[i]);
|
||
encryptData += tempBuf;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
|
||
//解密十六进制的密文字串，返回加密之前的普通文本字串。
|
||
bool Decrypt_AES_CBC(string & key, string & srcData, string & decryptData)
|
||
{
|
||
int keyLen = key.length();
|
||
int aesKeyLen = keyLen;
|
||
if (keyLen > AES192_KEYLEN)
|
||
{
|
||
aesKeyLen = AES256_KEYLEN;
|
||
}
|
||
else if (keyLen > AES128_KEYLEN && keyLen <= AES192_KEYLEN)
|
||
{
|
||
aesKeyLen = AES192_KEYLEN;
|
||
}
|
||
else if (keyLen > 0 && keyLen <= AES128_KEYLEN)
|
||
{
|
||
aesKeyLen = AES128_KEYLEN;
|
||
}
|
||
else
|
||
{
|
||
//LOGGER_ERROR("Input key length is error .");
|
||
printf("Input key length is error .\n");
|
||
return false;
|
||
}
|
||
|
||
if ((srcData.length() / AES_BLOCK_SIZE < 1) || (srcData.length() % AES_BLOCK_SIZE != 0))
|
||
{
|
||
//LOGGER_ERROR("Input lenth error - SrcData:" << srcData.c_str());
|
||
printf("Input lenth error ...\n");
|
||
return false;
|
||
}
|
||
|
||
char tempKey[AES256_KEYLEN + 1] = {0};
|
||
strncpy_s(tempKey, AES256_KEYLEN + 1, key.c_str(), keyLen);
|
||
tempKey[keyLen] = '\0';
|
||
char IV[AES_BLOCK_SIZE + 1] = { 0 };
|
||
strncpy_s(IV, AES_BLOCK_SIZE + 1, tempKey, AES_BLOCK_SIZE);
|
||
|
||
int dataLen = srcData.length()/2;
|
||
|
||
//Hex string to byte data
|
||
vector<byte> tempSrcData;
|
||
tempSrcData.resize(dataLen, '\0');
|
||
char * pstr = (char *)srcData.c_str();
|
||
for (int i = 0; i < dataLen; i++)
|
||
{
|
||
UINT tempValue = 0;
|
||
sscanf_s(pstr + i * 2, "%02x", &tempValue);
|
||
tempSrcData[i] = (byte)tempValue;
|
||
}
|
||
|
||
vector<char> tempDecryptData;
|
||
AES_KEY AesKey;
|
||
tempDecryptData.resize(dataLen+1, '\0');
|
||
|
||
//set encryption key
|
||
if (AES_set_decrypt_key((const unsigned char *)tempKey, aesKeyLen * 8, &AesKey)<0)
|
||
{
|
||
//LOGGER_ERROR("Unable to set encryption key in AES...");
|
||
printf("Unable to set encryption key in AES...\n");
|
||
return false;
|
||
}
|
||
//encryption
|
||
AES_cbc_encrypt((const unsigned char *)tempSrcData.data(), (unsigned char *)tempDecryptData.data(), dataLen, &AesKey, (unsigned char *)IV, AES_DECRYPT);
|
||
decryptData = string(tempDecryptData.data());
|
||
|
||
return true;
|
||
}
|
||
|
||
bool IsPathExist(const string & strPath)
|
||
{
|
||
int nRet = _access(strPath.c_str(), 0);
|
||
return 0 == nRet || EACCES == nRet;
|
||
}
|
||
bool FileRename(const std::string &OldName, const std::string &NewName) {
|
||
return (::MoveFileA(OldName.c_str(), NewName.c_str()) != FALSE);
|
||
}
|
||
|
||
/*函数名称：EncryFileEx
|
||
*参数名称：filename --文件的全路径
|
||
*参数名称：drcfilename --输出文件的全路径
|
||
*功能说明：采用Aes加密算法加密文件内容
|
||
*/
|
||
|
||
/*
|
||
int EncryptFileEx(std::string filename)
|
||
{
|
||
int ires = 0;
|
||
AES_KEY aes_key;
|
||
unsigned char key[16] = { 0 };
|
||
unsigned char inbuf[16] = { 0 };
|
||
unsigned char outbuf[16] = { 0 };
|
||
unsigned char szHeader[256] = { 0 };
|
||
//create the rand key
|
||
RAND_bytes(szHeader, 256);
|
||
memcpy_s(key, 16, szHeader + 100, 16);
|
||
|
||
FILE *pFile = nullptr;
|
||
fopen_s(&pFile, filename.c_str(), "rb");
|
||
if (!pFile)
|
||
{
|
||
ires = 1;
|
||
return ires;
|
||
}
|
||
//char *pBuf;
|
||
fseek(pFile, 0, SEEK_END);
|
||
int len = ftell(pFile);
|
||
rewind(pFile);
|
||
|
||
if (AES_set_encrypt_key(key, 128, &aes_key) == 0)//set encrpt key
|
||
{
|
||
std::string newfile = filename;
|
||
newfile += "1";
|
||
|
||
ULONG count = len % 16 == 0 ? len / 16 : len / 16 + 1;
|
||
|
||
memcpy_s(inbuf, 16, &len, sizeof(ULONG));
|
||
AES_encrypt(inbuf, outbuf, &aes_key);
|
||
//put the file size at the first 16 bytes of szHeader
|
||
memcpy_s(szHeader, 16, outbuf, 16);
|
||
|
||
FILE *nf = nullptr;
|
||
fopen_s(&nf, newfile.c_str(), "wb+");
|
||
if (!nf)
|
||
{
|
||
ires = 4;
|
||
}
|
||
else
|
||
{
|
||
//put szHeader at the first 256 bytes of file
|
||
fwrite(szHeader, 1, 256, nf);
|
||
for (ULONG k = 0; k < count; k++)
|
||
{
|
||
SecureZeroMemory(inbuf, 16);
|
||
SecureZeroMemory(outbuf, 16);
|
||
if (0 < fread(inbuf, 1, 16, pFile))
|
||
{
|
||
AES_encrypt(inbuf, outbuf, &aes_key);
|
||
fwrite(outbuf, 1, 16, nf);
|
||
}
|
||
}
|
||
fclose(nf);
|
||
}
|
||
fclose(pFile);
|
||
DeleteFileA(filename.c_str());
|
||
FileRename(newfile, filename);
|
||
}
|
||
else
|
||
{
|
||
fclose(pFile);
|
||
}
|
||
return ires;
|
||
}
|
||
*/
|
||
|
||
/*
|
||
*函数名称：DecryFileEx
|
||
*参数名称：filename --文件的全路径
|
||
*参数名称：drcfilename --输出文件的全路径
|
||
*功能说明：采用Aes解密算法加密文件内容
|
||
*/
|
||
/*
|
||
int DecryptFileEx(std::string filename, bool bToTmpFile)
|
||
{
|
||
int ires = 0;
|
||
AES_KEY aes_key;
|
||
long long last, lastlen = 0;
|
||
unsigned char key[16] = { 0 };
|
||
unsigned char inbuf[16] = { 0 };
|
||
unsigned char outbuf[16] = { 0 };
|
||
unsigned char szHeader[256] = { 0 };
|
||
|
||
FILE *pFile = nullptr;
|
||
fopen_s(&pFile, filename.c_str(), "rb");
|
||
if (!pFile)
|
||
{
|
||
ires = 1;
|
||
return ires;
|
||
}
|
||
//char *pBuf;
|
||
fseek(pFile, 0, SEEK_END); //point the file end
|
||
int len = ftell(pFile);
|
||
rewind(pFile);
|
||
//count the decrpt times of file
|
||
ULONG count = (len - 256) / 16;
|
||
if (count <= 0)
|
||
{
|
||
fclose(pFile);
|
||
ires = 2;
|
||
return ires;
|
||
}
|
||
//get key from file
|
||
if (0 == fread(szHeader, 1, 256, pFile))
|
||
{
|
||
fclose(pFile);
|
||
ires = 2;
|
||
return ires;
|
||
}
|
||
memcpy_s(key, 16, szHeader + 100, 16);
|
||
|
||
//start to decrpt file
|
||
if (AES_set_decrypt_key(key, 128, &aes_key) == 0)//set decrypt key
|
||
{
|
||
//computer the file size before encrpt
|
||
memcpy_s(inbuf, 16, szHeader, 16);
|
||
AES_decrypt(inbuf, outbuf, &aes_key);
|
||
memcpy_s(&lastlen, sizeof(ULONG), outbuf, sizeof(ULONG));
|
||
last = lastlen % 16; //the part less 16 bytes before encprt
|
||
//check file if the file is able to be decrpted or not
|
||
bool ret = last == 0 ? lastlen == len - 256 : lastlen + 16 - last == len - 256;
|
||
if (!ret)
|
||
{
|
||
fclose(pFile);
|
||
ires = 3;
|
||
return ires;
|
||
}
|
||
std::string newfile = filename;
|
||
newfile += "1";
|
||
//create temp file
|
||
FILE *nf = nullptr;
|
||
fopen_s(&nf, newfile.c_str(), "wb+");
|
||
if (!nf)
|
||
{
|
||
ires = 4;
|
||
}
|
||
else
|
||
{
|
||
//decrpt file contents
|
||
for (ULONG k = 0; k < count; k++)
|
||
{
|
||
SecureZeroMemory(inbuf, 16);
|
||
SecureZeroMemory(outbuf, 16);
|
||
|
||
if (0 < fread(inbuf, 1, 16, pFile))//read 16 bytes from file
|
||
{
|
||
AES_decrypt(inbuf, outbuf, &aes_key);//decrpt 16 bytes
|
||
if (k == count - 1)
|
||
{
|
||
fwrite(outbuf, 1, last == 0 ? 16 : last, nf);
|
||
}
|
||
else
|
||
{
|
||
fwrite(outbuf, 1, 16, nf);
|
||
}
|
||
}
|
||
}
|
||
fclose(nf);
|
||
}
|
||
fclose(pFile);
|
||
|
||
if (!bToTmpFile)
|
||
{
|
||
DeleteFileA(filename.c_str());
|
||
FileRename(newfile, filename);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
fclose(pFile);
|
||
}
|
||
return ires;
|
||
}
|
||
|
||
int GetAuthorizeConfigs(string filename, AuthorizeConfigs & configs)
|
||
{
|
||
int ires = 0;
|
||
AES_KEY aes_key;
|
||
long long last, lastlen = 0;
|
||
unsigned char key[16] = { 0 };
|
||
unsigned char inbuf[16] = { 0 };
|
||
unsigned char outbuf[16] = { 0 };
|
||
unsigned char szHeader[256] = { 0 };
|
||
|
||
FILE *pFile = nullptr;
|
||
fopen_s(&pFile, filename.c_str(), "rb");
|
||
if (!pFile)
|
||
{
|
||
ires = 1;
|
||
std::cout << "GetAuthorizeConfigs Failed , ErrCode:" << ires << " ." << std::endl;
|
||
return ires;
|
||
}
|
||
//char *pBuf;
|
||
fseek(pFile, 0, SEEK_END); //point the file end
|
||
int len = ftell(pFile);
|
||
rewind(pFile);
|
||
//count the decrpt times of file
|
||
ULONG count = (len - 256) / 16;
|
||
if (count <= 0)
|
||
{
|
||
fclose(pFile);
|
||
ires = 2;
|
||
std::cout << "GetAuthorizeConfigs Failed , ErrCode:" << ires << " ." << std::endl;
|
||
return ires;
|
||
}
|
||
//get key from file
|
||
if (0 == fread(szHeader, 1, 256, pFile))
|
||
{
|
||
fclose(pFile);
|
||
ires = 2;
|
||
std::cout << "GetAuthorizeConfigs Failed , ErrCode:" << ires << " ." << std::endl;
|
||
return ires;
|
||
}
|
||
memcpy_s(key, 16, szHeader + 100, 16);
|
||
|
||
//start to decrpt file
|
||
if (AES_set_decrypt_key(key, 128, &aes_key) == 0)//set decrypt key
|
||
{
|
||
//computer the file size before encrpt
|
||
memcpy_s(inbuf, 16, szHeader, 16);
|
||
AES_decrypt(inbuf, outbuf, &aes_key);
|
||
memcpy_s(&lastlen, sizeof(ULONG), outbuf, sizeof(ULONG));
|
||
last = lastlen % 16; //the part less 16 bytes before encprt
|
||
//check file if the file is able to be decrpted or not
|
||
bool ret = last == 0 ? lastlen == len - 256 : lastlen + 16 - last == len - 256;
|
||
if (!ret)
|
||
{
|
||
fclose(pFile);
|
||
ires = 3;
|
||
std::cout << "GetAuthorizeConfigs Failed , ErrCode:" << ires << " ." << std::endl;
|
||
return ires;
|
||
}
|
||
|
||
//decrpt file contents
|
||
stringstream tmpStram;
|
||
for (ULONG k = 0; k < count; k++)
|
||
{
|
||
SecureZeroMemory(inbuf, 16);
|
||
SecureZeroMemory(outbuf, 16);
|
||
|
||
if (0 < fread(inbuf, 1, 16, pFile))//read 16 bytes from file
|
||
{
|
||
AES_decrypt(inbuf, outbuf, &aes_key);//decrpt 16 bytes
|
||
if (k == count - 1)
|
||
{
|
||
tmpStram.write((char *)outbuf, last == 0 ? 16 : last);
|
||
}
|
||
else
|
||
{
|
||
tmpStram.write((char *)outbuf, 16);
|
||
}
|
||
}
|
||
}
|
||
|
||
//Get authorize configs
|
||
{
|
||
const int LINE_LENGTH = 256;
|
||
char lineBuf[LINE_LENGTH];
|
||
tmpStram.getline(lineBuf, LINE_LENGTH);
|
||
//Get file Type
|
||
string tmpType(lineBuf);
|
||
{
|
||
if (tmpType[tmpType.length() - 1] == '\n')
|
||
{
|
||
tmpType[tmpType.length() - 1] = '\0';
|
||
}
|
||
if (tmpType.length() < 1)
|
||
{
|
||
fclose(pFile);
|
||
ires = 5;
|
||
std::cout << "GetAuthorizeConfigs Failed , ErrCode:" << ires << " ." << std::endl;
|
||
return ires;
|
||
}
|
||
if (tmpType != string("1") && tmpType != string("2") && tmpType != string("3"))
|
||
{
|
||
fclose(pFile);
|
||
ires = 5;
|
||
std::cout << "GetAuthorizeConfigs Failed , ErrCode:" << ires << " ." << std::endl;
|
||
return ires;
|
||
}
|
||
configs._Type = tmpType;
|
||
}
|
||
//Get limit Time
|
||
tmpStram.getline(lineBuf, LINE_LENGTH);
|
||
string tmpTime(lineBuf);
|
||
{
|
||
if (tmpTime[tmpTime.length() - 1] == '\n')
|
||
{
|
||
tmpTime[tmpTime.length() - 1] = '\0';
|
||
}
|
||
if (tmpTime.length() < 1)
|
||
{
|
||
fclose(pFile);
|
||
ires = 6;
|
||
std::cout << "GetAuthorizeConfigs Failed , ErrCode:" << ires << " ." << std::endl;
|
||
return ires;
|
||
}
|
||
configs._LimitTime = tmpTime;
|
||
}
|
||
//Get package name
|
||
tmpStram.getline(lineBuf, LINE_LENGTH);
|
||
string tmpPackage(lineBuf);
|
||
{
|
||
if (tmpPackage[tmpPackage.length() - 1] == '\n')
|
||
{
|
||
tmpPackage[tmpPackage.length() - 1] = '\0';
|
||
}
|
||
if (tmpPackage.length() < 1)
|
||
{
|
||
fclose(pFile);
|
||
ires = 7;
|
||
std::cout << "GetAuthorizeConfigs Failed , ErrCode:" << ires << " ." << std::endl;
|
||
return ires;
|
||
}
|
||
configs._PackageName = tmpPackage;
|
||
}
|
||
//Get authorize Key
|
||
tmpStram.getline(lineBuf, LINE_LENGTH);
|
||
string tmpAuthorKey(lineBuf);
|
||
{
|
||
if (tmpAuthorKey[tmpAuthorKey.length() - 1] == '\n')
|
||
{
|
||
tmpAuthorKey[tmpAuthorKey.length() - 1] = '\0';
|
||
}
|
||
if (tmpAuthorKey.length() < 1)
|
||
{
|
||
fclose(pFile);
|
||
ires = 8;
|
||
std::cout << "GetAuthorizeConfigs Failed , ErrCode:" << ires << " ." << std::endl;
|
||
return ires;
|
||
}
|
||
configs._AuthorizeKey = tmpAuthorKey;
|
||
}
|
||
if (tmpType == string("3"))
|
||
{
|
||
//Get activate Url
|
||
tmpStram.getline(lineBuf, LINE_LENGTH);
|
||
string tmpActivateUrl(lineBuf);
|
||
{
|
||
if (tmpActivateUrl[tmpActivateUrl.length() - 1] == '\n')
|
||
{
|
||
tmpActivateUrl[tmpActivateUrl.length() - 1] = '\0';
|
||
}
|
||
if (tmpActivateUrl.length() < 1)
|
||
{
|
||
fclose(pFile);
|
||
ires = 9;
|
||
std::cout << "GetAuthorizeConfigs Failed , ErrCode:" << ires << " ." << std::endl;
|
||
return ires;
|
||
}
|
||
configs._ActivateUrl = tmpActivateUrl;
|
||
}
|
||
//Get activate local cipher
|
||
tmpStram.getline(lineBuf, LINE_LENGTH);
|
||
string tmpLocalCipher(lineBuf);
|
||
{
|
||
if (tmpLocalCipher[tmpLocalCipher.length() - 1] == '\n')
|
||
{
|
||
tmpLocalCipher[tmpLocalCipher.length() - 1] = '\0';
|
||
}
|
||
if (tmpLocalCipher.length() < 1)
|
||
{
|
||
fclose(pFile);
|
||
ires = 10;
|
||
std::cout << "GetAuthorizeConfigs Failed , ErrCode:" << ires << " ." << std::endl;
|
||
return ires;
|
||
}
|
||
configs._ActivateLocalCipher = tmpLocalCipher;
|
||
}
|
||
}
|
||
else if (tmpType == string("2"))
|
||
{
|
||
//Get ToolKey
|
||
tmpStram.getline(lineBuf, LINE_LENGTH);
|
||
string tmpToolKey(lineBuf);
|
||
{
|
||
if (tmpToolKey[tmpToolKey.length() - 1] == '\n')
|
||
{
|
||
tmpToolKey[tmpToolKey.length() - 1] = '\0';
|
||
}
|
||
if (tmpToolKey.length() < 1)
|
||
{
|
||
fclose(pFile);
|
||
ires = 11;
|
||
std::cout << "GetAuthorizeConfigs Failed , ErrCode:" << ires << " ." << std::endl;
|
||
return ires;
|
||
}
|
||
configs._ToolKey = tmpToolKey;
|
||
}
|
||
|
||
while (tmpStram.getline(lineBuf, LINE_LENGTH))
|
||
{
|
||
string tmpMacKey(lineBuf);
|
||
if (tmpMacKey[tmpMacKey.length() - 1] == '\n')
|
||
{
|
||
tmpMacKey[tmpMacKey.length() - 1] = '\0';
|
||
}
|
||
if (tmpMacKey.length() < 1)
|
||
{
|
||
continue;
|
||
}
|
||
if (tmpMacKey.length() != 45)
|
||
{
|
||
fclose(pFile);
|
||
ires = 12;
|
||
std::cout << "GetAuthorizeConfigs Failed , ErrCode:" << ires << " ." << std::endl;
|
||
return ires;
|
||
}
|
||
Mac_Key tmpMac_Key;
|
||
tmpMac_Key._Mac = tmpMacKey.substr(0, 12);
|
||
tmpMac_Key._MacKey = tmpMacKey.substr(13, 32);
|
||
configs._MacKeys.push_back(tmpMac_Key);
|
||
}
|
||
if (configs._MacKeys.size() < 1)
|
||
{
|
||
fclose(pFile);
|
||
ires = 13;
|
||
std::cout << "GetAuthorizeConfigs Failed , ErrCode:" << ires << " ." << std::endl;
|
||
return ires;
|
||
}
|
||
}
|
||
|
||
fclose(pFile);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ires = 4;
|
||
std::cout << "GetAuthorizeConfigs Failed , ErrCode:" << ires << " ." << std::endl;
|
||
fclose(pFile);
|
||
}
|
||
return ires;
|
||
}
|
||
*/
|
||
#pragma endregion AES_IMPL
|
||
|
||
Request::Request(void)
|
||
{
|
||
//do nothing
|
||
}
|
||
|
||
Request::~Request(void)
|
||
{
|
||
//do nothing
|
||
}
|
||
|
||
int Request::post(string &url,string &data,int timeout)
|
||
{
|
||
int resultReturn = -1;
|
||
CURL *curl;
|
||
CURLM *multi_handle;
|
||
int still_running;
|
||
struct curl_httppost *formpost=NULL;
|
||
struct curl_httppost *lastptr=NULL;
|
||
struct curl_slist *headerlist=NULL;
|
||
static const char buf[] = "Expect:";
|
||
Json::Reader reader;
|
||
Json::Value value;
|
||
if (!reader.parse(data, value, false))
|
||
{
|
||
resultReturn = -1;
|
||
return resultReturn;
|
||
}
|
||
Json::Value::Members member = value.getMemberNames();
|
||
for(Json::Value::Members::iterator iter = member.begin(); iter != member.end(); ++iter)
|
||
{
|
||
string hand = *iter;
|
||
string val;
|
||
try{
|
||
val = value[hand].asString();
|
||
}
|
||
catch(...)
|
||
{
|
||
val = value[hand].toStyledString();
|
||
}
|
||
curl_formadd(&formpost,
|
||
&lastptr,
|
||
CURLFORM_COPYNAME, hand.c_str(),
|
||
CURLFORM_COPYCONTENTS, val.c_str(),
|
||
CURLFORM_END);
|
||
}
|
||
curl_formadd(&formpost,
|
||
&lastptr,
|
||
CURLFORM_COPYNAME, "submit",
|
||
CURLFORM_COPYCONTENTS, "send",
|
||
CURLFORM_END);
|
||
curl = curl_easy_init();
|
||
multi_handle = curl_multi_init();
|
||
headerlist = curl_slist_append(headerlist, buf);
|
||
if(curl && multi_handle)
|
||
{
|
||
curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
|
||
curl_easy_setopt(curl, CURLOPT_VERBOSE, 0L);
|
||
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headerlist);
|
||
curl_easy_setopt(curl, CURLOPT_HTTPPOST, formpost);
|
||
|
||
//访问Wanda盒子时不需要https，访问SnapCam时需要Https。
|
||
string urlFlag = url.substr(0, 5);
|
||
std::transform(urlFlag.begin(), urlFlag.end(), urlFlag.begin(), ::tolower);
|
||
if (urlFlag == string("https"))
|
||
{
|
||
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, false);//设定为不验证证书和HOST
|
||
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, false);
|
||
}
|
||
|
||
curl_multi_add_handle(multi_handle, curl);
|
||
curl_multi_perform(multi_handle, &still_running);
|
||
do
|
||
{
|
||
struct timeval time_out;
|
||
int rc; /* select() return code */
|
||
fd_set fdread;
|
||
fd_set fdwrite;
|
||
fd_set fdexcep;
|
||
int maxfd = -1;
|
||
long curl_timeo = timeout;
|
||
FD_ZERO(&fdread);
|
||
FD_ZERO(&fdwrite);
|
||
FD_ZERO(&fdexcep);
|
||
time_out.tv_sec = 1;
|
||
time_out.tv_usec = 0;
|
||
curl_multi_timeout(multi_handle, &curl_timeo);
|
||
if(curl_timeo >= 0)
|
||
{
|
||
time_out.tv_sec = curl_timeo / 1000;
|
||
if(time_out.tv_sec > 1)
|
||
time_out.tv_sec = 1;
|
||
else
|
||
time_out.tv_usec = (curl_timeo % 1000) * 1000;
|
||
}
|
||
curl_multi_fdset(multi_handle, &fdread, &fdwrite, &fdexcep, &maxfd);
|
||
rc = select(maxfd+1, &fdread, &fdwrite, &fdexcep, &time_out);
|
||
switch(rc)
|
||
{
|
||
case -1:
|
||
cout << "select error!" << endl;
|
||
break;
|
||
case 0:
|
||
default:
|
||
curl_multi_perform(multi_handle, &still_running);
|
||
break;
|
||
}
|
||
|
||
}
|
||
while(still_running);
|
||
int msgs_left;
|
||
CURLMsg *msg;
|
||
msg = curl_multi_info_read(multi_handle, &msgs_left);
|
||
resultReturn = msg->data.result;
|
||
|
||
curl_multi_cleanup(multi_handle);
|
||
curl_easy_cleanup(curl);
|
||
curl_formfree(formpost);
|
||
curl_slist_free_all (headerlist);
|
||
}
|
||
return resultReturn;
|
||
}
|
||
|
||
size_t write_func(void* data, size_t size, size_t nmemb, void* content)
|
||
{
|
||
long totalSize = size*nmemb;
|
||
std::string* symbolBuffer = (std::string*)content;
|
||
if (symbolBuffer)
|
||
{
|
||
symbolBuffer->append((char *)data, ((char*)data) + totalSize);
|
||
}
|
||
return totalSize;
|
||
}
|
||
|
||
int Request::post(string &url,string &data,string &files, string & strData,int timeout)
|
||
{
|
||
int resultReturn = -1;
|
||
CURL *curl;
|
||
|
||
struct curl_httppost *formpost=NULL;
|
||
struct curl_httppost *lastptr=NULL;
|
||
struct curl_slist *headerlist=NULL;
|
||
static const char buf[] = "Expect:";
|
||
Json::Reader reader;
|
||
Json::Value json_data;
|
||
Json::Value json_files;
|
||
if (!reader.parse(data, json_data, false))
|
||
{
|
||
resultReturn = -1;
|
||
return resultReturn;
|
||
}
|
||
Json::Value::Members data_member = json_data.getMemberNames();
|
||
for(Json::Value::Members::iterator iter = data_member.begin(); iter != data_member.end(); ++iter)
|
||
{
|
||
string hand = *iter;
|
||
string val;
|
||
try{
|
||
val = json_data[hand].asString();
|
||
}
|
||
catch(...)
|
||
{
|
||
val = json_data[hand].toStyledString();
|
||
}
|
||
curl_formadd(&formpost,
|
||
&lastptr,
|
||
CURLFORM_COPYNAME, hand.c_str(),
|
||
CURLFORM_COPYCONTENTS, val.c_str(),
|
||
CURLFORM_END);
|
||
}
|
||
|
||
if (files.length() > 0)
|
||
{
|
||
if (!reader.parse(files, json_files, false))
|
||
{
|
||
resultReturn = -1;
|
||
return resultReturn;
|
||
}
|
||
Json::Value::Members files_member = json_files.getMemberNames();
|
||
for (Json::Value::Members::iterator iter = files_member.begin(); iter != files_member.end(); ++iter)
|
||
{
|
||
string hand = *iter;
|
||
string val = json_files[hand].asString();
|
||
curl_formadd(&formpost,
|
||
&lastptr,
|
||
CURLFORM_COPYNAME, hand.c_str(),
|
||
CURLFORM_FILE, val.c_str(),
|
||
CURLFORM_END);
|
||
curl_formadd(&formpost,
|
||
&lastptr,
|
||
CURLFORM_COPYNAME, hand.c_str(),
|
||
CURLFORM_COPYCONTENTS, val.c_str(),
|
||
CURLFORM_END);
|
||
}
|
||
}
|
||
|
||
curl_formadd(&formpost,
|
||
&lastptr,
|
||
CURLFORM_COPYNAME, "submit",
|
||
CURLFORM_COPYCONTENTS, "send",
|
||
CURLFORM_END);
|
||
curl = curl_easy_init();
|
||
|
||
headerlist = curl_slist_append(headerlist, buf);
|
||
if(curl)
|
||
{
|
||
curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
|
||
curl_easy_setopt(curl, CURLOPT_VERBOSE, 0L);
|
||
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headerlist);
|
||
curl_easy_setopt(curl, CURLOPT_HTTPPOST, formpost);
|
||
|
||
//访问Wanda盒子时不需要https，访问SnapCam时需要Https。
|
||
string urlFlag = url.substr(0, 5);
|
||
std::transform(urlFlag.begin(), urlFlag.end(), urlFlag.begin(), ::tolower);
|
||
if(urlFlag == string("https"))
|
||
{
|
||
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, false);//设定为不验证证书和HOST
|
||
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, false);
|
||
}
|
||
|
||
curl_easy_setopt(curl, CURLOPT_TIMEOUT, 8);//接收数据时超时设置，如果3秒内数据未接收完，直接退出
|
||
curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 8);//连接超时，这个数值如果设置太短可能导致数据请求不到就断开了
|
||
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_func);// 设置回调函数
|
||
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)&strData);//设置写数据
|
||
|
||
CURLcode code = curl_easy_perform(curl);//执行请求
|
||
if (code == CURLcode::CURLE_OK)
|
||
{
|
||
long responseCode = 0;
|
||
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &responseCode);
|
||
if (responseCode > 0 && !strData.empty())
|
||
{
|
||
resultReturn = 1;//表示已经获取到服务器端的返回信息
|
||
}
|
||
}
|
||
|
||
curl_easy_cleanup(curl);
|
||
curl_formfree(formpost);
|
||
curl_slist_free_all (headerlist);
|
||
}
|
||
return resultReturn;
|
||
}
|
||
|
||
size_t callbackfunction(void *ptr, size_t size, size_t nmemb, void* userdata)
|
||
{
|
||
FILE* stream = (FILE*)userdata;
|
||
if (!stream) {
|
||
printf("!!! No stream\n");
|
||
return 0;
|
||
}
|
||
|
||
size_t written = fwrite((FILE*)ptr, size, nmemb, stream);
|
||
return written;
|
||
}
|
||
|
||
bool Request::downloadFile(string & fileUrl,string & fileName)
|
||
{
|
||
FILE* fp = NULL;
|
||
fopen_s(&fp,fileName.c_str(), "wb");
|
||
if (!fp) {
|
||
printf("!!! Failed to create file on the disk\n");
|
||
return false;
|
||
}
|
||
|
||
CURL* curlCtx = curl_easy_init();
|
||
curl_easy_setopt(curlCtx, CURLOPT_URL, fileUrl.c_str());
|
||
curl_easy_setopt(curlCtx, CURLOPT_WRITEDATA, fp);
|
||
curl_easy_setopt(curlCtx, CURLOPT_WRITEFUNCTION, callbackfunction);
|
||
curl_easy_setopt(curlCtx, CURLOPT_FOLLOWLOCATION, 1);
|
||
|
||
//访问Wanda盒子时不需要https，访问SnapCam时需要Https。
|
||
string urlFlag = fileUrl.substr(0, 5);
|
||
std::transform(urlFlag.begin(), urlFlag.end(), urlFlag.begin(), ::tolower);
|
||
if (urlFlag == string("https"))
|
||
{
|
||
curl_easy_setopt(curlCtx, CURLOPT_SSL_VERIFYPEER, false);//设定为不验证证书和HOST
|
||
curl_easy_setopt(curlCtx, CURLOPT_SSL_VERIFYHOST, false);
|
||
}
|
||
|
||
CURLcode rc = curl_easy_perform(curlCtx);
|
||
if (rc) {
|
||
printf("!!! Failed to download: %s\n", fileUrl.c_str());
|
||
fclose(fp);
|
||
return false;
|
||
}
|
||
|
||
long res_code = 0;
|
||
curl_easy_getinfo(curlCtx, CURLINFO_RESPONSE_CODE, &res_code);
|
||
if (!((res_code == 200 || res_code == 201) && rc != CURLE_ABORTED_BY_CALLBACK)) {
|
||
printf("!!! Response code: %d\n", res_code);
|
||
fclose(fp);
|
||
return false;
|
||
}
|
||
|
||
curl_easy_cleanup(curlCtx);
|
||
fclose(fp);
|
||
|
||
return true;
|
||
}
|