Exemple #1
0
int database_add_orphan_transaction(struct database* db, unsigned char const* hash, struct transaction const* tx)
{
    mongoc_collection_t* collection = mongoc_client_get_collection(db->client, database_name(db), "transactions");
    
    // Convert the transaction to a bson document
    bson_t* doc = bson_new();
    transaction_bson(tx, doc);

    // Set the hash
    BSON_APPEND_BINARY(doc, "hash", BSON_SUBTYPE_BINARY, (uint8_t*)hash, 32);

    // Give it a new id
    bson_oid_t oid;
    bson_oid_init(&oid, NULL);
    BSON_APPEND_OID(doc, "_id", &oid);

    // Orphan -> height = -1
    BSON_APPEND_INT32(doc, "height", -1);

#if 0
    // Print json
    char* str = bson_as_json(doc, NULL);
    printf("%s\n", str);
    bson_free(str);
#endif

    // Perform insert
    bson_error_t error;
    if(mongoc_collection_insert(collection, MONGOC_INSERT_NONE, doc, NULL, &error) == 0) {
        printf("MongoDB error: %s\n", error.message);
    }

    bson_destroy(doc);
    mongoc_collection_destroy(collection);
    return 0;
}
Exemple #2
0
static void getaddressbyID(char *msg,mongoc_collection_t *coll,char * deviceId,char * device_name){

   mongoc_cursor_t *cursor;
   bson_t *doc;
   bson_t *query;
   char *str;
   query = bson_new ();
   bson_oid_t de_oid;
   bson_oid_init_from_string(&de_oid, deviceId);
   BSON_APPEND_OID (query, "_id",&de_oid);
   cursor = mongoc_collection_find (coll, MONGOC_QUERY_NONE, 0, 0, 0, query, NULL, NULL);
   double ivalue=0;
   int buse=0;
   double lat;
   double lon;
   //char lat[256];
   //char lon[256];
   //memset(lat,'\0',256);
   //memset(lon,'\0',256);
   while (mongoc_cursor_next (cursor, &doc)) {
          str = bson_as_json (doc, NULL);
          //printf ("%s\n", str);
          bson_free (str);
          bson_iter_t iter;
          bson_iter_t sub_iter;
          if (bson_iter_init (&iter, doc)) {
            while (bson_iter_next (&iter)) {
               //printf ("Found a field named: %s\n", bson_iter_key (&iter));
               
               bson_value_t *value;
               value = bson_iter_value (&iter);
               //printf("type %d\n",value->value_type);
               if (value->value_type == BSON_TYPE_DOUBLE) {
                 if(strcmp(bson_iter_key (&iter),"lat")==0){
                    (lat=value->value.v_double); 
                 }
                 if(strcmp(bson_iter_key (&iter),"lon")==0){
                    (lon=value->value.v_double); 
                 }
               }
               if (value->value_type == BSON_TYPE_UTF8) {
                 if(strcmp(bson_iter_key (&iter),"device_name")==0){
                    strcpy(device_name,value->value.v_utf8.str);   
                 }
               }
            }
          }
   }
   bson_destroy (query);


   




    CURL *curl;
    CURLcode res;    
    curl = curl_easy_init();
    if (curl) {
      static char str[20480];
      memset(str,'\0',20480);
      char url[1028];
      memset(url,'\0',1028);
      sprintf(url,"http://api.map.baidu.com/geocoder/v2/?ak=IDvNBsejl9oqMbPF316iKsXR&output=json&location=%.8f,%.8f",lat,lon);
      printf("%s\n",url);
      curl_easy_setopt(curl, CURLOPT_URL, url);
      curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
      curl_easy_setopt(curl, CURLOPT_WRITEDATA, str);  
      res = curl_easy_perform(curl);
      printf("%s\n",str);
      char *s = strstr(str, "formatted_address");
      if(NULL!=s){
         s=strstr(s, "\"");
         s=strstr(s+1, "\"");
         printf("\n%s\n",s);
         char *p=strstr(s+1, "\"");
         int len=strlen(s)-strlen(p)-1;
         strncpy(msg,s+1,len);
         msg[len]='\0';
         printf("msg:%s\n",msg); 
         printf("\n\n"); 
      }
      curl_easy_cleanup(curl);
    }
}
Exemple #3
0
static void do_alarm(mongoc_collection_t *sensorcoll,char * se_id,char * alarmType,char * upperBoundC,char *lowerBoundC, char *duration,char *target,char * contactId,char* addr,mongoc_collection_t *alarmlogcoll,char* userId,char *device_name,char * de_id){
   mongoc_cursor_t *cursor;
   bson_t *doc;
   bson_t *query;
   char *str;
   query = bson_new ();
   bson_oid_t se_oid;
   bson_oid_init_from_string(&se_oid, se_id);
   BSON_APPEND_OID (query, "_id",&se_oid);
   cursor = mongoc_collection_find (sensorcoll, MONGOC_QUERY_NONE, 0, 0, 0, query, NULL, NULL);
   double ivalue=0;
   double dalarmtime=0;
   int interval=0;
   int balarm=0;
   int buse=0;
   char name[1024];
   memset(name,0,1024);
   while (mongoc_cursor_next (cursor, &doc)) {
          str = bson_as_json (doc, NULL);
          printf ("%s\n", str);
          bson_free (str);
          bson_iter_t iter;
          bson_iter_t sub_iter;
          if (bson_iter_init (&iter, doc)) {
            while (bson_iter_next (&iter)) {
               //printf ("Found a field named: %s\n", bson_iter_key (&iter));
               
               bson_value_t *value;
               value = bson_iter_value (&iter);
               //printf("type %d\n",value->value_type);
               if (value->value_type == BSON_TYPE_INT32) {
                 if(strcmp(bson_iter_key (&iter),"value")==0){
                    printf("value %d\n", value->value.v_int32);         
                    ivalue=value->value.v_double; 
                    buse =1;
                 }else if(strcmp(bson_iter_key (&iter),"interval")==0){
                    interval=value->value.v_int32; 
                 }else if(strcmp(bson_iter_key (&iter),"balarm")==0){
                    balarm=value->value.v_int32; 
                 }
               }
               if(strcmp(bson_iter_key (&iter),"value")==0){
                      printf("value type %d,%d\n",value->value_type,BSON_TYPE_INT32);
               }
               if (value->value_type == BSON_TYPE_DOUBLE) {
                 if(strcmp(bson_iter_key (&iter),"value")==0){
                    //printf("value %d\n", (int)value->value.v_double);        
                    buse =1;
                    ivalue=value->value.v_double; 
                 }
                 if(strcmp(bson_iter_key (&iter),"alarmtime")==0){
                    dalarmtime=value->value.v_double; 
                 }
               }
               if (value->value_type == BSON_TYPE_UTF8) {
                 if(strcmp(bson_iter_key (&iter),"name")==0){
                    //printf("value %d\n", (int)value->value.v_double);        
                    strcpy(name,value->value.v_utf8.str); 
                 }
                 if(strcmp(bson_iter_key (&iter),"value")==0){
                    //printf("value %d\n", (int)value->value.v_double);        
                    ivalue=atof(value->value.v_utf8.str); 
                    buse =1;
                 }
               }
            }
          }
   }
   bson_destroy (query);
   printf("se_id:%s,buse:%d\n",se_id,buse);
   printf("alarmType:%s,%f : %s,%s",alarmType,ivalue,upperBoundC,lowerBoundC);
   time_t t;  
   t = time(NULL);  
   struct tm *lt;  
   int ii = time(&t); 
   int bdoalarm=1;
   if(balarm==1){
      bdoalarm=1;
      if(dalarmtime>0 &&interval>0){
          if((ii-dalarmtime)<3600){
             bdoalarm=0;
          }
        
      }
   }
   if(buse ==1){
     if(strcmp(alarmType,"val_above")==0){
        int iupper=atoi(upperBoundC);
        if(iupper<ivalue){
         printf("val_above %d value\n",iupper,ivalue);
         char msg[2048];
         memset(msg,0,2048);
         snprintf(msg, sizeof(msg) - 1,
			"故障报警:%s的%s数值高于%d,位置是%s,请及时处理!",
                        device_name,
			name,
			iupper,
			addr);
         char buf[1024];  
         URLEncodeGBK(msg, strlen(msg), buf,sizeof(buf));  
         printf("%s\n",buf);
         printf("alarm info: %s\n",msg);
         if(bdoalarm>0){
           int code=sendsms_c(buf,contactId);
           saveAlarmLog(alarmlogcoll,se_id,code,contactId,msg,userId,device_name,name,de_id);
           updateAlarm(sensorcoll,se_id,interval+1,1);
           printf("send sms \n");
         }
        }else {
          updateAlarm(sensorcoll,se_id,0,0);
        }
     }else if(strcmp(alarmType,"val_below")==0){
        int iupper=atoi(lowerBoundC);
        if(iupper>ivalue){
         printf("val_below %d  value %d\n",iupper,ivalue);
         char msg[2048];
         memset(msg,0,2048);
         snprintf(msg, sizeof(msg) - 1,
			"故障报警:%s的%s数值低于%d,位置是%s,请及时处理!",
                        device_name,
			name,
			iupper,
			addr);
         char buf[1024];  
         URLEncodeGBK(msg, strlen(msg), buf,sizeof(buf));  
         printf("%s\n",buf);
         printf("alarm info: %s\n",msg);
         if(bdoalarm>0){
           int code=sendsms_c(buf,contactId);
           saveAlarmLog(alarmlogcoll,se_id,code,contactId,msg,userId,device_name,name,de_id);
           updateAlarm(sensorcoll,se_id,interval+1,1);
           printf("send sms \n");
         }
        }else {
          updateAlarm(sensorcoll,se_id,0,0);
        }
     }else if(strcmp(alarmType,"switch_on")==0){
        if(ivalue==1){
         char msg[2048];
         memset(msg,0,2048);
         snprintf(msg, sizeof(msg) - 1,
			"故障报警:%s,%s,位置是%s,请及时处理!",
                        device_name,
			name,
			addr);
         char buf[1024];  
         URLEncodeGBK(msg, strlen(msg), buf,sizeof(buf));  
         printf("%s\n",buf);
         printf("alarm info: %s\n",msg);
         if(bdoalarm>0){
           int code=sendsms_c(buf,contactId);
           saveAlarmLog(alarmlogcoll,se_id,code,contactId,msg,userId,device_name,name,de_id);
           updateAlarm(sensorcoll,se_id,interval+1,1);
           printf("send sms \n");
         }
        }else {
          updateAlarm(sensorcoll,se_id,0,0);
        }
     }else if(strcmp(alarmType,"offline")==0){
        if(ivalue==1){
         char msg[2048];
         memset(msg,0,2048);
         snprintf(msg, sizeof(msg) - 1,
			"故障报警:%s,%s,位置是%s,请及时处理!",
                        device_name,
			name,
			addr);
         char buf[1024];  
         URLEncodeGBK(msg, strlen(msg), buf,sizeof(buf));  
         printf("%s\n",buf);
         printf("alarm info: %s\n",msg);
         if(bdoalarm>0){
           int code=sendsms_c(buf,contactId);
           saveAlarmLog(alarmlogcoll,se_id,code,contactId,msg,userId,device_name,name,de_id);
           updateAlarm(sensorcoll,se_id,interval+1,1);
           printf("send sms \n");
         }
        }else {
          updateAlarm(sensorcoll,se_id,0,0);
        }
     }
   }
}
static void
test_split_insert (void)
{
   mongoc_bulk_write_flags_t write_flags = MONGOC_BULK_WRITE_FLAGS_INIT;
   mongoc_write_command_t command;
   mongoc_write_result_t result;
   mongoc_collection_t *collection;
   mongoc_client_t *client;
   bson_oid_t oid;
   bson_t **docs;
   bson_t reply = BSON_INITIALIZER;
   bson_error_t error;
   mongoc_server_stream_t *server_stream;
   int i;
   bool r;

   client = test_framework_client_new ();
   assert (client);

   collection = get_test_collection (client, "test_split_insert");
   assert (collection);

   docs = (bson_t **)bson_malloc (sizeof(bson_t*) * 3000);

   for (i = 0; i < 3000; i++) {
      docs [i] = bson_new ();
      bson_oid_init (&oid, NULL);
      BSON_APPEND_OID (docs [i], "_id", &oid);
   }

   _mongoc_write_result_init (&result);

   _mongoc_write_command_init_insert (&command,
                                      docs[0],
                                      write_flags,
                                      ++client->cluster.operation_id,
                                      true);

   for (i = 1; i < 3000; i++) {
      _mongoc_write_command_insert_append (&command, docs[i]);
   }

   server_stream = mongoc_cluster_stream_for_writes (&client->cluster, &error);
   ASSERT_OR_PRINT (server_stream, error);
   _mongoc_write_command_execute (&command, client, server_stream, collection->db,
                                  collection->collection, NULL, 0, &result);

   r = _mongoc_write_result_complete (&result, 2, collection->write_concern,
                                      &reply, &error);
   ASSERT_OR_PRINT (r, error);
   assert (result.nInserted == 3000);

   _mongoc_write_command_destroy (&command);
   _mongoc_write_result_destroy (&result);

   ASSERT_OR_PRINT (mongoc_collection_drop (collection, &error), error);

   for (i = 0; i < 3000; i++) {
      bson_destroy (docs [i]);
   }

   bson_free (docs);
   mongoc_server_stream_cleanup (server_stream);
   mongoc_collection_destroy (collection);
   mongoc_client_destroy (client);
}
Exemple #5
0
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 void
test_many_return (void)
{
   mongoc_collection_t *collection;
   mongoc_client_t *client;
   mongoc_cursor_t *cursor;
   bson_error_t error;
   const bson_t *doc = NULL;
   bson_oid_t oid;
   bson_t query = BSON_INITIALIZER;
   bson_t **docs;
   size_t len;
   bool r;
   int i;

   client = mongoc_client_new (gTestUri);
   ASSERT (client);

   collection = get_test_collection (client, "test_many_return");
   ASSERT (collection);

   docs = bson_malloc (sizeof(bson_t*) * 5000);

   for (i = 0; i < 5000; i++) {
      docs [i] = bson_new ();
      bson_oid_init (&oid, NULL);
      BSON_APPEND_OID (docs [i], "_id", &oid);
   }

BEGIN_IGNORE_DEPRECATIONS;

   r = mongoc_collection_insert_bulk (collection, MONGOC_INSERT_NONE, (const bson_t **)docs, 5000, NULL, &error);

END_IGNORE_DEPRECATIONS;

   assert (r);

   for (i = 0; i < 5000; i++) {
      bson_destroy (docs [i]);
   }

   bson_free (docs);

   cursor = mongoc_collection_find (collection, MONGOC_QUERY_NONE, 0, 0, 6000, &query, NULL, NULL);
   assert (cursor);
   bson_destroy (&query);

   i = 0;

   while (mongoc_cursor_next (cursor, &doc)) {
      assert (doc);
      i++;
   }

   assert (i == 5000);

   r = mongoc_cursor_next (cursor, &doc);
   assert (!r);

   mongoc_cursor_destroy (cursor);

   r = mongoc_collection_drop (collection, &error);
   assert (r);

   mongoc_collection_destroy (collection);
   mongoc_client_destroy (client);
}
Exemple #7
0
static int mongodb_log(struct ast_cdr *cdr)
{
	int ret = -1;
    bson_t *doc = NULL;
    mongoc_collection_t *collection = NULL;

	if(dbpool == NULL) {
		ast_log(LOG_ERROR, "unexpected error, no connection pool\n");
		return ret;
	}

	mongoc_client_t *dbclient = mongoc_client_pool_pop(dbpool);
	if(dbclient == NULL) {
		ast_log(LOG_ERROR, "unexpected error, no client allocated\n");
		return ret;
	}

	do {
	    bson_error_t error;

	    doc = bson_new();
		if(doc == NULL) {
			ast_log(LOG_ERROR, "cannot make a document\n");
			break;
		}
	    mongoc_collection_t *collection = mongoc_client_get_collection(dbclient, dbname, dbcollection);
		if(collection == NULL) {
			ast_log(LOG_ERROR, "cannot get such a collection, %s, %s\n", dbname, dbcollection);
			break;
		}
		BSON_APPEND_UTF8(doc, "clid", cdr->clid);
		BSON_APPEND_UTF8(doc, "src", cdr->src);
		BSON_APPEND_UTF8(doc, "dst", cdr->dst);
		BSON_APPEND_UTF8(doc, "dcontext", cdr->dcontext);
		BSON_APPEND_UTF8(doc, "channel", cdr->channel);
		BSON_APPEND_UTF8(doc, "dstchannel", cdr->dstchannel);
		BSON_APPEND_UTF8(doc, "lastapp", cdr->lastapp);
		BSON_APPEND_UTF8(doc, "lastdata", cdr->lastdata);
		BSON_APPEND_UTF8(doc, "disposition", ast_cdr_disp2str(cdr->disposition));
		BSON_APPEND_UTF8(doc, "amaflags", ast_channel_amaflags2string(cdr->amaflags));
		BSON_APPEND_UTF8(doc, "accountcode", cdr->accountcode);
		BSON_APPEND_UTF8(doc, "uniqueid", cdr->uniqueid);
		BSON_APPEND_UTF8(doc, "userfield", cdr->userfield);
		BSON_APPEND_UTF8(doc, "peeraccount", cdr->peeraccount);
		BSON_APPEND_UTF8(doc, "linkedid", cdr->linkedid);
		BSON_APPEND_INT32(doc, "duration", cdr->duration);
		BSON_APPEND_INT32(doc, "billsec", cdr->billsec);
		BSON_APPEND_INT32(doc, "sequence", cdr->sequence);
		BSON_APPEND_TIMEVAL(doc, "start", &cdr->start);
		BSON_APPEND_TIMEVAL(doc, "answer", &cdr->answer);
		BSON_APPEND_TIMEVAL(doc, "end", &cdr->end);
		if (serverid)
			BSON_APPEND_OID(doc, SERVERID, serverid);

		if(!mongoc_collection_insert(collection, MONGOC_INSERT_NONE, doc, NULL, &error))
			ast_log(LOG_ERROR, "insertion failed, %s\n", error.message);

		ret = 0; // success
	} while(0);

	if (collection)
	    mongoc_collection_destroy(collection);
	if (doc)
	    bson_destroy(doc);
	mongoc_client_pool_push(dbpool, dbclient);
	return ret;
}
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;
}
/*********************************************************************************************
F_SECUNDARIA: Creando un BSON del archivo, para insertalo en la DB                 TESTEADO =)
****************************/
bson_t * crearDocumentoParaLaDB(char * nombreDelArchivo, long tamanioDelArchivo, int dirPadreDelArchivo, t_dictionary * diccionarioDeBloques)
//Va eliminando el diccionario que ingresa por parametro :D
{
	bson_t child; bson_t child2; bson_t child3; bson_t child4;
	bson_oid_t oid;

	int cantidadTotalDeBloques;
	int identificadorDelBloque = 0;

	t_dictionary* copiasDelBloqueX;
	t_copiaX* copiaX;

	char * iDelBloque;
	//FIN DECLARACION DE VARIABLES


	bson_t * documento = bson_new();
	// ::: Estructura BASICA del documento :::
		bson_oid_init (&oid, NULL);
        BSON_APPEND_OID (documento, "_id", &oid);
		BSON_APPEND_UTF8 (documento, "nombreDelArchivo", nombreDelArchivo);
	 	BSON_APPEND_INT32 (documento, "tamanio", tamanioDelArchivo);
	 	BSON_APPEND_INT32 (documento, "dirPadre", dirPadreDelArchivo);
		BSON_APPEND_INT32 (documento, "estado", 1);

	cantidadTotalDeBloques = dictionary_size(diccionarioDeBloques);

		BSON_APPEND_INT32 (documento, "cantidadDeBloques", cantidadTotalDeBloques);
	// ::: Estructura de BLOQUES del documento :::
	//Guardando los N bloques con copias 3
	bson_append_document_begin (documento, "Bloques", 7, &child);

		while(identificadorDelBloque < cantidadTotalDeBloques)
		{
			iDelBloque = string_itoa(identificadorDelBloque);

			bson_append_document_begin (&child, iDelBloque, 1, &child2);

				copiasDelBloqueX = (t_dictionary*) dictionary_get( diccionarioDeBloques, iDelBloque );

				//Guardando la cantidad de copias del bloque X
					BSON_APPEND_INT32 (&child2, "cantidadDeCopias", 3);

				//Guardando las 3 copias para el bloque X
				bson_append_array_begin (&child2, "copias", 6, &child4);

					copiaX = (t_copiaX*) dictionary_get( copiasDelBloqueX, "1" );

					int Guachin= dictionary_size(copiasDelBloqueX);
					bson_append_document_begin (&child4, "0", 1, &child3);
						bson_append_int32(&child3,"IP", 2, (*copiaX).IP);
						bson_append_int32(&child3, "puerto", 6, (*copiaX).puerto);
						bson_append_int32(&child3, "numBloque", 9, (*copiaX).numBloque);
					bson_append_document_end (&child4, &child3);

					copiaX = (t_copiaX*) dictionary_get( copiasDelBloqueX, "2" );

					bson_append_document_begin (&child4, "1", 1, &child3);
						bson_append_int32(&child3,"IP", 2, (*copiaX).IP);
						bson_append_int32(&child3, "puerto", 6, (*copiaX).puerto);
						bson_append_int32(&child3, "numBloque", 9, (*copiaX).numBloque);
					bson_append_document_end (&child4, &child3);

					copiaX = (t_copiaX*) dictionary_get( copiasDelBloqueX, "3" );

					bson_append_document_begin (&child4, "2", 1, &child3);
						bson_append_int32(&child3,"IP", 2, (*copiaX).IP);
						bson_append_int32(&child3, "puerto", 6, (*copiaX).puerto);
						bson_append_int32(&child3, "numBloque", 9, (*copiaX).numBloque);
					bson_append_document_end (&child4, &child3);

				bson_append_array_end (&child2, &child4);

				dictionary_clean(copiasDelBloqueX);
				dictionary_destroy(copiasDelBloqueX);

			//Anido las 3 copias al bloque X
			bson_append_document_end (&child, &child2);

			free(iDelBloque);
			identificadorDelBloque++;
		};
	//::Estructura BASICA + estructura BLOQUES::
	bson_append_document_end (documento, &child);

	//Elimino el diccionarioDeBloques
	dictionary_clean(diccionarioDeBloques);
	dictionary_destroy(diccionarioDeBloques);

	return documento;
}
Exemple #10
0
//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// 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++;

}