static void saveAlarmLog(mongoc_collection_t *coll,char* se_id,int code,char * tel,char * msg,char* userId,char * device_name,char* name,char * de_id){
bson_t *sdoc = bson_new ();
bson_oid_t a_oid;
bson_oid_init (&a_oid, NULL);
BSON_APPEND_OID (sdoc, "_id", &a_oid);
//BSON_APPEND_OID (sdoc, "device_id", de_oid);
//BSON_APPEND_UTF8 (sdoc, "name", name);
//BSON_APPEND_INT32 (sdoc, "sensorType", sensorType);
BSON_APPEND_INT32 (sdoc, "code", code);
BSON_APPEND_UTF8 (sdoc, "mobile", tel);
BSON_APPEND_UTF8 (sdoc, "sendmsg", msg);
BSON_APPEND_UTF8 (sdoc, "user_id", userId);
BSON_APPEND_UTF8 (sdoc, "se_id", se_id);
BSON_APPEND_UTF8 (sdoc, "de_id", de_id);
BSON_APPEND_UTF8 (sdoc, "device_name", device_name);
BSON_APPEND_UTF8 (sdoc, "sensor_name", name);
time_t timep;
time(&timep);
BSON_APPEND_DOUBLE (sdoc, "time", timep);
bson_error_t serror;
if (!mongoc_collection_insert (coll, MONGOC_INSERT_NONE, sdoc, NULL, &serror)) {
fprintf (stderr, "%s\n", serror.message);
}
bson_destroy (sdoc);
}
bool
bson_append_double_from_s (bson_t *bson,
const char *key,
const char *value)
{
bool ret = true;
if (value && strcmp ("\\N", value) != 0)
ret = BSON_APPEND_DOUBLE (bson, key, atof (value));
return ret;
}
void switch_value(lua_State *L, int index, bson_t* bson, int level, const char* key)
{
switch(lua_type(L, index))
{
case LUA_TTABLE:
{
int is_a=is_array(L, index);
if (is_a)
{
bson_t child;
//start array
BSON_APPEND_ARRAY_BEGIN(bson, key, &child);
iterate_table(L, index, &child, 0, level+1, NULL);
bson_append_array_end(bson, &child);
}
else
{
bson_t child;
//start map
BSON_APPEND_DOCUMENT_BEGIN(bson, key, &child);
iterate_table(L, index, &child, 1, level+1, NULL);
bson_append_document_end(bson, &child);
}
break;
}
case LUA_TNIL:
{
BSON_APPEND_NULL(bson, key);
break;
}
case LUA_TNUMBER:
{
BSON_APPEND_DOUBLE(bson, key, lua_tonumber(L, index));
break;
}
case LUA_TBOOLEAN:
{
BSON_APPEND_BOOL(bson, key, lua_toboolean(L, index));
break;
}
case LUA_TSTRING:
{
BSON_APPEND_UTF8(bson, key, lua_tostring(L, index));
break;
}
case LUA_TUSERDATA:
{
// switch userdata type
if (luaL_checkudata_ex(L, index, REGEX_METATABLE))
{
cbson_regex_t* regex = check_cbson_regex(L, index);
BSON_APPEND_REGEX (bson, key, regex->regex, regex->options);
}
else if (luaL_checkudata_ex(L, index, OID_METATABLE))
{
cbson_oid_t* oid = check_cbson_oid(L, index);
bson_oid_t boid;
bson_oid_init_from_string (&boid, oid->oid);
BSON_APPEND_OID (bson, key, &boid);
}
else if (luaL_checkudata_ex(L, index, BINARY_METATABLE))
{
cbson_binary_t* bin = check_cbson_binary(L, index);
size_t binary_len = b64_pton (bin->data, NULL, 0);
unsigned char* buf=malloc(binary_len+1);
b64_pton(bin->data, buf, binary_len+1);
BSON_APPEND_BINARY(bson, key, bin->type, buf, binary_len);
free(buf);
}
else if (luaL_checkudata_ex(L, index, SYMBOL_METATABLE))
{
cbson_symbol_t* sym = check_cbson_symbol(L, index);
BSON_APPEND_SYMBOL(bson, key, sym->symbol);
}
else if (luaL_checkudata_ex(L, index, REF_METATABLE))
{
cbson_ref_t* ref = check_cbson_ref(L, index);
bson_oid_t boid;
bson_oid_init_from_string (&boid, ref->id);
BSON_APPEND_DBPOINTER(bson, key, ref->ref, &boid);
}
else if (luaL_checkudata_ex(L, index, MINKEY_METATABLE))
{
check_cbson_minkey(L, index);
BSON_APPEND_MINKEY(bson, key);
}
else if (luaL_checkudata_ex(L, index, MAXKEY_METATABLE))
{
check_cbson_maxkey(L, index);
BSON_APPEND_MAXKEY(bson, key);
}
else if (luaL_checkudata_ex(L, index, TIMESTAMP_METATABLE))
{
cbson_timestamp_t* time = check_cbson_timestamp(L, index);
BSON_APPEND_TIMESTAMP(bson, key, time->timestamp, time->increment);
}
else if (luaL_checkudata_ex(L, index, INT64_METATABLE) || luaL_checkudata_ex(L, index, UINT64_METATABLE))
{
cbson_int64_t i = cbson_int64_check(L, index);
if (i < INT32_MIN || i > INT32_MAX)
{
BSON_APPEND_INT64(bson, key, i);
}
else
{
BSON_APPEND_INT32(bson, key, (int32_t)i);
}
}
else if (luaL_checkudata_ex(L, index, CODE_METATABLE))
{
cbson_code_t* code = check_cbson_code(L, index);
BSON_APPEND_CODE(bson, key, code->code);
}
else if (luaL_checkudata_ex(L, index, CODEWSCOPE_METATABLE))
{
cbson_codewscope_t* code = check_cbson_codewscope(L, index);
BSON_APPEND_CODE_WITH_SCOPE(bson, key, code->code, NULL);
}
else if (luaL_checkudata_ex(L, index, UNDEFINED_METATABLE))
{
check_cbson_undefined(L, index);
BSON_APPEND_UNDEFINED(bson, key);
}
else if (luaL_checkudata_ex(L, index, DATE_METATABLE))
{
BSON_APPEND_DATE_TIME(bson, key, cbson_date_check(L, index));
}
break;
}
case LUA_TFUNCTION:
case LUA_TTHREAD:
case LUA_TLIGHTUSERDATA:
default:
break; // or bail out?
}
}
static bool appendBsonValue(bson_t *bson, const QString &key, const QVariant &value)
{
const QLatin1String oidkey("_id");
bool ok = true;
int type = value.type();
// _id
if (key == oidkey) {
QByteArray oidVal = value.toByteArray();
if (oidVal.length() == 24) {
// ObjectId
bson_oid_t oid;
bson_oid_init_from_string(&oid, oidVal.data());
BSON_APPEND_OID(bson, oidkey.latin1(), &oid);
} else {
int id = value.toInt(&ok);
if (ok) {
BSON_APPEND_INT32(bson, oidkey.latin1(), id);
} else {
BSON_APPEND_UTF8(bson, oidkey.latin1(), value.toString().toUtf8().data());
}
}
return true;
}
switch (type) {
case QVariant::Int:
BSON_APPEND_INT32(bson, qPrintable(key), value.toInt(&ok));
break;
case QVariant::String:
BSON_APPEND_UTF8(bson, qPrintable(key), value.toString().toUtf8().data());
break;
case QVariant::LongLong:
BSON_APPEND_INT64(bson, qPrintable(key), value.toLongLong(&ok));
break;
case QVariant::Map:
BSON_APPEND_DOCUMENT(bson, qPrintable(key), (const bson_t *)TBson::toBson(value.toMap()).constData());
break;
case QVariant::Double:
BSON_APPEND_DOUBLE(bson, qPrintable(key), value.toDouble(&ok));
break;
case QVariant::Bool:
BSON_APPEND_BOOL(bson, qPrintable(key), value.toBool());
break;
case QVariant::DateTime: {
#if QT_VERSION >= 0x040700
BSON_APPEND_DATE_TIME(bson, qPrintable(key), value.toDateTime().toMSecsSinceEpoch());
#else
QDateTime utcDate = value.toDateTime().toUTC();
qint64 ms = utcDate.time().msec();
qint64 tm = utcDate.toTime_t() * 1000LL;
if (ms > 0) {
tm += ms;
}
BSON_APPEND_DATE_TIME(bson, qPrintable(key), tm);
#endif
break; }
case QVariant::ByteArray: {
QByteArray ba = value.toByteArray();
BSON_APPEND_BINARY(bson, qPrintable(key), BSON_SUBTYPE_BINARY, (uint8_t *)ba.constData(), ba.length());
break; }
case QVariant::List: // FALL THROUGH
case QVariant::StringList: {
bson_t child;
BSON_APPEND_ARRAY_BEGIN(bson, qPrintable(key), &child);
int i = 0;
for (auto &var : value.toList()) {
appendBsonValue(&child, QString::number(i++), var);
}
bson_append_array_end(bson, &child);
break; }
case QVariant::Invalid:
BSON_APPEND_UNDEFINED(bson, qPrintable(key));
break;
default:
tError("toBson() failed to convert name:%s type:%d", qPrintable(key), type);
ok = false;
break;
}
return ok;
}
//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// Event Function
//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
void gps_gateway_process(int x, short int y, void *pargs)
{
unsigned int unFromAddrLen;
int nByte = 0;
int nSendByte = 0;
unsigned char aReqBuffer[512];
unsigned char aRespBuffer[512];
struct sockaddr_in stFromAddr;
bson_oid_t oid;
bson_t *doc;
const bson_t *result;
bson_t *query;
int i = 0;
int command = 0;
int monitor_type = 0;
char telephone[10];
char text_message[240];
int length;
char strBaseinfo[10];
AGPS_info * agps;
cell_info * cell;
unFromAddrLen = sizeof(stFromAddr);
memset(aReqBuffer,0x00,512);
memset(aRespBuffer,0x00,512);
if ((nByte = recvfrom(x, aReqBuffer, sizeof(aReqBuffer), 0,
(struct sockaddr *)&stFromAddr, &unFromAddrLen)) == -1)
{
printf("error occured while receivingn");
}
//proc();
data_frame_head *msg = (data_frame_head *) aReqBuffer;
content_gps_up *g = (content_gps_up *)(aReqBuffer + sizeof(data_frame_head));
//异或校验
//异或校验
unsigned char xor = *(aReqBuffer + nByte - 2);
if( xor != check_xor(aReqBuffer, nByte - 2))
{
return ;//drop down BAD check xor.
}
switch (msg->cmd)
{
case CMD_TERMINAL_GPS_UP :
//解析位置信息，得到经纬度
fprintf(stderr,"protocal head %x \n",msg->data_head[0] );
fprintf(stderr,"cmd %x \n", msg->cmd );
fprintf(stderr,"length %d \n", ntohs(msg->length) );
//fprintf(stderr,"product_id %u\n",get_product_id(msg->terminal_id));
fprintf(stderr,"product_id %u\n",get_product_id(g->terminal_id));
fprintf(stderr,"flow_id %x \n", ntohs(g->flow_id) );
fprintf(stderr,"data_type %x \n", g->data_type );
fprintf(stderr," time " );
for ( i = 0 ; i< 6 ;i++)
fprintf(stderr," %x \n", g->base_info.date_time[i] );
/////////
//经纬度
fprintf(stderr," latitude " );
for ( i = 0 ; i< 4 ;i++)
fprintf(stderr,"%x \n", g->base_info.latitude[i] );
fprintf(stderr," longitude " );
for ( i = 0 ; i< 4 ;i++)
fprintf(stderr," %x \n", g->base_info.longitude[i] );
/////////
fprintf(stderr,"speed %u \n", ntohs(g->base_info.speed));
fprintf(stderr,"fangxiang %u \n", ntohs(g->base_info.direction));
fprintf(stderr,"gaodu %u\n", ntohs(g->base_info.high));
fprintf(stderr,"定位状态 %c\n", g->base_info.pos_station);
fprintf(stderr,"是否应答 %x\n", g->base_info.need_response);
if (ntohs(msg->length) > sizeof (content_gps_up)) {
fprintf(stderr,"含有附带信息\n");
unsigned char *attach_info = aReqBuffer + sizeof(data_frame_head) + sizeof(content_gps_up);
fprintf(stderr,"附带信息类型：%x\n",*attach_info);
fprintf(stderr,"附带信息长度：%d\n",*(attach_info+1));
switch (*(attach_info))
{
case 0x01:
break;
case 0x02:
fprintf(stderr,"基站信息\n");
agps = (AGPS_info * ) ( attach_info + 2);
cell = (cell_info * ) ( attach_info + 2 + sizeof(AGPS_info));
fprintf(stderr,"\n国家编码");
fprintf(stderr," %x ", ntohl(agps->country_code) );
fprintf(stderr,"\n运营编码");
fprintf(stderr," %x ", ntohl(agps->mobile_code) );
fprintf(stderr,"\n运基站定位\n");
for ( i = 0 ; i< agps->base_count ;i++){
fprintf(stderr," 基站 %d 位置区编码 %d\n", i+1, ntohs(cell->lacN) );
fprintf(stderr," 基站 %d 小区编码 %d \n", i+1, ntohs(cell->cellN) );
fprintf(stderr," 基站 %d 信号强度 %x \n", i+1, cell->signalN );
cell++;
}
break;
case 0x0C:
case 0x1E:
case 0x1F:
case 0x28:
case 0x40:
case 0x41:
case 0x42:
case 0x43:
case 0x44:
case 0x45:
break;
}
}
if( g->data_type == 0x80 || g->data_type == 0x82 || g->data_type == 0x8E )
{
//保存mongodb
unsigned char timegps[15];
unsigned char latitude[10];
unsigned char longitude[10];
double lat;
double lng;
doc = bson_new ();
bson_oid_init (&oid, NULL);
BSON_APPEND_OID (doc, "_id", &oid);
BSON_APPEND_INT32 (doc, "id",get_product_id(g->terminal_id));
get_gps_time(g->base_info.date_time, timegps );
BSON_APPEND_UTF8 (doc, "timestamp", timegps);
lat = bcd2longitude(g->base_info.latitude, latitude );
lng = bcd2longitude(g->base_info.longitude, longitude );
BSON_APPEND_UTF8 (doc, "latitude", latitude);
BSON_APPEND_UTF8 (doc, "longitude", longitude);
BSON_APPEND_DOUBLE (doc, "lat", lat);
BSON_APPEND_DOUBLE (doc, "lng", lng);
BSON_APPEND_INT32 (doc, "speed", ntohs(g->base_info.speed));
BSON_APPEND_INT32 (doc, "direction", ntohs(g->base_info.direction));
BSON_APPEND_INT32 (doc, "high", ntohs(g->base_info.high));
BSON_APPEND_INT32 (doc, "pos_station", g->base_info.pos_station);
if (ntohs(msg->length) > sizeof (content_gps_up)) {
unsigned char *attach_info = aReqBuffer + sizeof(data_frame_head) + sizeof(content_gps_up);
switch (*(attach_info))
{
case 0x01:
break;
case 0x02:
agps = (AGPS_info * ) ( attach_info + 2);
cell = (cell_info * ) ( attach_info + 2 + sizeof(AGPS_info));
fprintf(stderr,"\n国家编码");
fprintf(stderr," %x ", ntohl(agps->country_code) );
BSON_APPEND_INT32 (doc, "country_code", ntohl(agps->country_code));
fprintf(stderr,"\n运营编码");
fprintf(stderr," %x ", ntohl(agps->mobile_code) );
BSON_APPEND_INT32 (doc, "mobile_code", ntohl(agps->mobile_code));
fprintf(stderr,"\n运基站定位\n");
for ( i = 0 ; i< agps->base_count ;i++){
fprintf(stderr," 基站 %d 位置区编码 %d\n", i+1, ntohs(cell->lacN) );
fprintf(stderr," 基站 %d 小区编码 %d \n", i+1, ntohs(cell->cellN) );
fprintf(stderr," 基站 %d 信号强度 %x \n", i+1, cell->signalN );
sprintf(strBaseinfo,"lac%d",i);
BSON_APPEND_INT32 (doc, strBaseinfo, ntohs(cell->lacN) );
sprintf(strBaseinfo,"cell%d",i);
BSON_APPEND_INT32 (doc, strBaseinfo, ntohs(cell->cellN) );
sprintf(strBaseinfo,"signal%d",i);
BSON_APPEND_INT32 (doc, strBaseinfo, cell->signalN );
cell++;
}
break;
case 0x0C:
case 0x1E:
case 0x1F:
case 0x28:
case 0x40:
case 0x41:
case 0x42:
case 0x43:
case 0x44:
case 0x45:
break;
}
}
if (!mongoc_collection_insert (collection, MONGOC_INSERT_NONE, doc, NULL, &error)) {
printf ("Insert failed: %s\n", error.message);
}
bson_destroy (doc);
}
else if( g->data_type == 0x85 )
{
//delete from mongo
query = bson_new ();
BSON_APPEND_INT32 (query, "id",get_product_id(g->terminal_id));
if( ! mongoc_collection_remove(collection_cmd, MONGOC_DELETE_NONE, query, NULL, &error))
{
fprintf(stderr,"remove command failed \n" );
}
bson_destroy (query);
}
if (g->base_info.need_response == 0x01)
{
send_22_response( x, aRespBuffer , g->flow_id, xor , g->data_type,
stFromAddr, unFromAddrLen );
}
break;
case CMD_TERMINAL_INFO_UP :
fprintf(stderr,"CMD_TERMINAL_INFO_UP\n");
content_info_up * t = (content_info_up *)(aReqBuffer + sizeof(data_frame_head));
fprintf(stderr,"parameter %x \n", t->parameter );
if(t->parameter == 0x01)
{
sent_time_response( x, aRespBuffer , g->terminal_id, stFromAddr, unFromAddrLen );
}
break;
case CMD_VERSION_INFO_UP :
fprintf(stderr,"CMD_VERSION_INFO_UP");
break;
case CMD_VOICE_UP :
fprintf(stderr,"CMD_VOICE_UP");
break;
default:
break;
}
//get command from mongo
char *str;
query = bson_new ();
BSON_APPEND_INT32 (query, "id",get_product_id(g->terminal_id));
cursor = mongoc_collection_find (collection_cmd, MONGOC_QUERY_NONE, 0, 0, 0, query, NULL, NULL);
//while (mongoc_cursor_next (cursor, &doc)) {
// mongoc_cursor_next (cursor, &result);
while (mongoc_cursor_next (cursor, (const bson_t **) &doc)) {
bson_iter_t iter;
bson_iter_t sub_iter;
str = bson_as_json (doc, NULL);
fprintf (stderr, "%s\n", str);
bson_free (str);
if (bson_iter_init (&iter, doc) && bson_iter_find_descendant (&iter, "cmd", &sub_iter)) {
fprintf (stderr,"Found key \"%s\" in sub document.\n", bson_iter_key (&sub_iter));
printf ("The type of a.b.c.d is: %d\n", (int)bson_iter_type (&sub_iter));
command = (int)bson_iter_int32 (&sub_iter);
}
if (bson_iter_init (&iter, doc) && bson_iter_find_descendant (&iter, "parameter", &sub_iter)) {
fprintf (stderr,"Found key \"%s\" in sub document.\n", bson_iter_key (&sub_iter));
printf ("The type of a.b.c.d is: %d\n", (int)bson_iter_type (&sub_iter));
strcpy (telephone , bson_iter_utf8 (&sub_iter,&length));
}
if (bson_iter_init (&iter, doc) && bson_iter_find_descendant (&iter, "monitor_type", &sub_iter)) {
fprintf (stderr,"Found key \"%s\" in sub document.\n", bson_iter_key (&sub_iter));
printf ("The type of a.b.c.d is: %d\n", (int)bson_iter_type (&sub_iter));
monitor_type = (int)bson_iter_int32 (&sub_iter);
}
if (bson_iter_init (&iter, doc) && bson_iter_find_descendant (&iter, "text_message", &sub_iter)) {
fprintf (stderr,"Found key \"%s\" in sub document.\n", bson_iter_key (&sub_iter));
printf ("The type of a.b.c.d is: %d\n", (int)bson_iter_type (&sub_iter));
strcpy (text_message , bson_iter_utf8 (&sub_iter,&length));
}
}
mongoc_cursor_destroy (cursor);
bson_destroy (query);
//send command to handring
if (command == 1)
{
send_monitor_cmd( x, aRespBuffer , g->terminal_id, stFromAddr, unFromAddrLen ,monitor_type, telephone);
}
else if (command == 9)
{
send_sleep_cmd( x, aRespBuffer , g->terminal_id, stFromAddr, unFromAddrLen );
}
else if (command == 2)
{
send_set_cmd( x, aRespBuffer , g->terminal_id, stFromAddr, unFromAddrLen ,text_message);
}
else{
//为了避免长时间使用网络。在通信6次发送一个休眠指令
if( (msg->cmd == CMD_TERMINAL_GPS_UP) && (check_state(g->terminal_id) == MAX_STANDBY) )
{
send_sleep_cmd( x, aRespBuffer , g->terminal_id, stFromAddr, unFromAddrLen );
}
}
//printf("Function called buffer is %sn",aReqBuffer);
g_count++;
}
