void sslTest2()
{
tracef("ssl test 2 begin: ssl send data.");
Context::Ptr pContext = new Context(Context::TLSV1_CLIENT_USE, "", Context::VERIFY_NONE);
SecureStreamSocket sss(pContext);
SocketAddress sa("127.0.0.1", 12222);
sss.connect(sa, Timespan(3, 0));
DynamicStruct ds;
ds["type"] = "request";
ds["action"] = "server.token";
Timestamp t;
UInt64 tms = t.epochMicroseconds();
char tms_str[32];
snprintf(tms_str, 31, "%llu", tms);
std::string key = "alpha2015";
key += tms_str;
MD5Engine md5;
md5.update(key);
const DigestEngine::Digest& digest = md5.digest();
std::string md5key = DigestEngine::digestToHex(digest);
DynamicStruct param;
param["key"] = md5key;
param["timestamp"] = tms_str;
param["dev_name"] = "lock1";
param["dev_type"] = "sc-01";
param["uuid"] = "SC00000001";
ds["param"] = param;
tracef("data send: %s.", ds.toString().c_str());
sss.sendBytes(ds.toString().c_str(), ds.toString().length());
sss.close();
tracef("socket closed.");
tracef("ssl test 2 finished.\n");
}
void AMFWriter::writeDate(const Timestamp& date){
(UInt32&)lastReference=0;
if(!_amf3) {
if(amf0Preference) {
writer.write8(AMF_DATE);
writer << ((double)date.epochMicroseconds()/1000);
writer.write16(0); // Timezone, TODO?
return;
}
writer.write8(AMF_AVMPLUS_OBJECT);
}
writer.write8(AMF3_DATE);
writer.write8(0x01);
writer << ((double)date.epochMicroseconds()/1000);
_references.push_back(AMF3_DATE);
(UInt32&)lastReference=_references.size();
}
int COperationRecord::getRecords(Timestamp& start, Timestamp& end, int limit, int offset, std::vector<OperationRecordNode>& data_set)
{
if(m_session_ptr == NULL)
{
warnf("%s, %d: Please init database first.", __FILE__, __LINE__);
return -1;
}
data_set.clear();
Timestamp tstart = start;
Int64 ststart = tstart.epochMicroseconds();
Timestamp tend = end - 1;
Int64 stend = tend.epochMicroseconds();
Statement sselect(*m_session_ptr);
sselect << "SELECT `Timestamp`, `Operation`, `Username`, `Schema` FROM `Operation` WHERE `Timestamp` BETWEEN ? AND ? LIMIT ? OFFSET ?",
use(ststart),
use(stend),
use(limit),
use(offset);
int ret = 0;
try
{
ret = sselect.execute();
}
catch(Exception& e)
{
warnf("%s, %d: Select from Operation failed[%s].", __FILE__, __LINE__, e.message().c_str());
return -1;
}
RecordSet rs(sselect);
bool more = rs.moveFirst();
while(more)
{
OperationRecordNode op_node;
std::size_t col = 0;
op_node.timestamp = rs[col++].convert<Int64>();
op_node.operation = rs[col++].convert<int>();
op_node.username = rs[col++].convert<std::string>();
op_node.schema = rs[col++].convert<int>();
more = rs.moveNext();
data_set.push_back(op_node);
}
return ret;
}
void regTest5()
{
tracef("reg test 5 begin:reg twice");
Context::Ptr pContext = new Context(Context::TLSV1_CLIENT_USE, "", Context::VERIFY_NONE);
SecureStreamSocket sss(pContext);
SocketAddress sa("127.0.0.1", 12222);
sss.connect(sa, Timespan(3, 0));
DynamicStruct ds;
ds["type"] = "request";
ds["action"] = "server.token";
Timestamp t;
UInt64 tms = t.epochMicroseconds();
char tms_str[32];
snprintf(tms_str, 31, "%llu", tms);
std::string key = "alpha2015";
key += tms_str;
MD5Engine md5;
md5.update(key);
const DigestEngine::Digest& digest = md5.digest();
std::string md5key = DigestEngine::digestToHex(digest);
DynamicStruct param;
param["key"] = md5key;
param["timestamp"] = tms_str;
param["dev_name"] = "lock3";
param["dev_type"] = "sc-01";
param["uuid"] = "SC00000003";
ds["param"] = param;
tracef("data send: %s.", ds.toString().c_str());
sss.sendBytes(ds.toString().c_str(), ds.toString().length());
char buf[1024] = {0, };
sss.receiveBytes(buf, 1024);
JSON::Parser parser;
Dynamic::Var var = parser.parse(buf);
JSON::Object::Ptr pObj = var.extract<JSON::Object::Ptr>();
DynamicStruct ds_recv = *pObj;
std::string token = ds_recv["param"]["token"];
DynamicStruct ds_reg;
ds_reg["type"] = "request";
ds_reg["action"] = "server.register";
DynamicStruct param_reg;
param_reg["token"] = token;
param_reg["uuid"] = "SC00000003";
ds_reg["param"] = param_reg;
StreamSocket ss;
SocketAddress sa2("127.0.0.1", 13333);
ss.connect(sa2, Timespan(3, 0));
ss.sendBytes(ds_reg.toString().c_str(), ds_reg.toString().length());
tracef("reg data send: %s.", ds_reg.toString().c_str());
memset(buf, 0, 1024);
ss.receiveBytes(buf, 1024);
tracef("receive bytes: %s.", buf);
ss.close();
Thread::sleep(2000);
StreamSocket ss2;
ss2.connect(sa2, Timespan(3, 0));
tracef("reg data send again: %s.", ds_reg.toString().c_str());
ss2.sendBytes(ds_reg.toString().c_str(), ds_reg.toString().length());
memset(buf, 0, 1024);
ss2.receiveBytes(buf, 1024);
tracef("recv data: %s.", buf);
ss2.close();
tracef("reg test 5 finished.");
}
int main(int argc, char** argv)
{
if(argc < 4)
return 0;
std::string host = argv[1];
UInt64 ssl_port = atoi(argv[2]);
UInt64 reg_port = atoi(argv[3]);
SocketAddress ssl_addr(host, ssl_port);
SocketAddress reg_addr(host, reg_port);
Context::Ptr pContext = new Context(Context::TLSV1_CLIENT_USE, "", Context::VERIFY_NONE);
SecureStreamSocket* ssl_sock = new SecureStreamSocket(pContext);
try
{
ssl_sock->connect(ssl_addr, Timespan(3, 0));
}
catch(Exception& e)
{
warnf("%s, %d: message: %s.", __FILE__, __LINE__, e.message().c_str());
}
tracef("%s, %d: now sleep.", __FILE__, __LINE__);
Thread::sleep(3 * 1000);
char buf[512] = {0, };
DynamicStruct ssl_buf;
ssl_buf["type"] = "request";
ssl_buf["action"] = "server.token";
DynamicStruct ssl_param;
Timestamp t;
UInt64 tms = t.epochMicroseconds();
char tms_str[32] = {0, };
snprintf(tms_str, 31, "%llu", tms);
ssl_param["timestamp"] = tms_str;
std::string key = "alpha2015";
key += tms_str;
MD5Engine md5;
md5.update(key);
const DigestEngine::Digest& digest = md5.digest();
std::string md5key = DigestEngine::digestToHex(digest);
ssl_param["key"] = md5key;
ssl_param["uuid"] = "hjhjhjhj";
ssl_param["dev_type"] = "abc";
ssl_param["dev_name"] = "cba";
ssl_buf["param"] = ssl_param;
snprintf(buf, 511, "%s", ssl_buf.toString().c_str());
tracef("%s, %d: send buf: %s\n", __FILE__, __LINE__, buf);
ssl_sock->sendBytes(buf, 512);
memset(buf, 0, 512);
if(ssl_sock->poll(Timespan(30, 0), Socket::SELECT_READ) > 0)
{
ssl_sock->receiveBytes(buf, 512);
tracef("%s, %d: receive buf: %s\n", __FILE__, __LINE__, buf);
}
ssl_sock->close();
delete ssl_sock;
pContext = NULL;
Dynamic::Var var;
JSON::Parser parser;
try
{
var = parser.parse(buf);
}
catch(Exception& e)
{
warnf("%s, %d: %s\n", __FILE__, __LINE__, e.message().c_str());
return 0;
}
JSON::Object::Ptr obj = var.extract<JSON::Object::Ptr>();
DynamicStruct ssl_recv = *obj;
std::string token = ssl_recv["token"];
DynamicStruct reg_buf;
reg_buf["action"] = "register";
reg_buf["token"] = token;
reg_buf["uuid"] = "hjhjhjhj";
reg_buf["devType"] = "abc";
memset(buf, 0, 512);
snprintf(buf, 511, "%s", reg_buf.toString().c_str());
StreamSocket* reg_sock = new StreamSocket(reg_addr);
reg_sock->sendBytes(buf, 512);
memset(buf, 0, 512);
if(reg_sock->poll(Timespan(3, 0), Socket::SELECT_READ) > 0)
{
reg_sock->receiveBytes(buf, 512);
}
Thread::sleep(2000);
while(1)
{
if(reg_sock->poll(Timespan(3, 0), Socket::SELECT_READ) > 0)
{
memset(buf, 0, 512);
reg_sock->receiveBytes(buf, 512);
parser.reset();
Dynamic::Var recv_request = parser.parse(buf);
JSON::Object::Ptr req_obj = recv_request.extract<JSON::Object::Ptr>();
DynamicStruct req_ds = *req_obj;
tracef("recv request:%s\n", req_ds.toString().c_str());
req_ds["type"] = "response";
req_ds["result"] = "good";
snprintf(buf, 512, "%s", req_ds.toString().c_str());
reg_sock->sendBytes(buf, 512);
infof("send response[%s].\n", buf);
char c;
c = getchar();
if(c == 'q')
break;
}
}
delete reg_sock;
return 0;
}
