[+] Add and verify new event

[*] DAG events operations

dap_chain_cs_dag.c

@@ -39,6 +39,8 @@ typedef struct dap_chain_cs_dag_event_item {
 
 typedef struct dap_chain_cs_dag_pvt {
     dap_chain_cs_dag_event_item_t * events;
+    dap_chain_cs_dag_event_item_t * events_trashhold;
+
     dap_chain_cs_dag_event_item_t * events_round_new;
     dap_chain_cs_dag_event_item_t * events_round_prev_lasts;
 } dap_chain_cs_dag_pvt_t;
@@ -150,7 +152,34 @@ void dap_chain_cs_dag_delete(dap_chain_t * a_chain)
  */
 static int s_chain_callback_atom_add(dap_chain_t * a_chain, dap_chain_atom_t * a_atom)
 {
-    return -1; // TODO
+    int ret = s_chain_callback_atom_verify (a_chain, a_atom);
+    if ( ret != 0 ){
+        log_it(L_WARNING,"Wrong event, can't accept, verification returned %d",ret);
+        return  -1;
+    }
+    dap_chain_cs_dag_t * l_dag = DAP_CHAIN_CS_DAG(a_chain);
+    dap_chain_cs_dag_event_t * l_event = (dap_chain_cs_dag_event_t *) a_atom;
+
+    ret = l_dag->callback_cs_input(l_dag,l_event);
+    if ( ret != 0 ){
+        log_it(L_WARNING,"Consensus can't accept the event, verification returned %d",ret);
+        return  -2;
+    }
+    dap_chain_cs_dag_event_item_t * l_event_item = DAP_NEW_Z(dap_chain_cs_dag_event_item_t);
+    l_event_item->event = l_event;
+    dap_hash_fast(l_event, dap_chain_cs_dag_event_calc_size(l_event),&l_event_item->hash );
+
+    dap_chain_cs_dag_event_item_t * l_event_search = NULL;
+    HASH_FIND(hh, PVT(l_dag)->events,&l_event_item->hash,sizeof (l_event_search->hash),  l_event_search);
+    if ( l_event_search ) {
+        char * l_hash_str = dap_chain_hash_fast_to_str_new(&l_event_item->hash);
+        log_it(L_ERROR, "Dag event %s is already present in dag",l_hash_str);
+        DAP_DELETE(l_event_item);
+        DAP_DELETE(l_hash_str);
+        return -3;
+    }
+    HASH_ADD(hh, PVT(l_dag)->events,hash,sizeof (l_event_item->hash),  l_event_item);
+    return 0;
 }
 
 
@@ -164,7 +193,7 @@ static int s_chain_callback_atom_verify(dap_chain_t * a_chain, dap_chain_atom_t
 {
     dap_chain_cs_dag_t * l_dag = DAP_CHAIN_CS_DAG(a_chain);
     dap_chain_cs_dag_event_t * l_event = (dap_chain_cs_dag_event_t *) a_atom;
-    return l_dag->callback_event_input ( l_dag, l_event );
+    return l_dag->callback_cs_verify ( l_dag, l_event );
 }
 
 /**

dap_chain_cs_dag.h

@@ -35,8 +35,8 @@ typedef struct dap_chain_cs_dag
     dap_chain_t * chain;
     bool is_single_line;
     dap_chain_cs_dag_callback_t callback_delete;
-    dap_chain_cs_dag_callback_event_t callback_event_input;
-    dap_chain_cs_dag_callback_event_t callback_event_verify;
+    dap_chain_cs_dag_callback_event_t callback_cs_input;
+    dap_chain_cs_dag_callback_event_t callback_cs_verify;
 
     void * _pvt;
     void * _inheritor;

dap_chain_cs_dag_event.c

@@ -42,60 +42,43 @@
  * @param a_hashes_count
  * @return
  */
-dap_chain_cs_dag_event_t * dap_chain_cs_dag_event_new(dap_chain_cs_dag_t * a_dag,dap_chain_datum_t * a_datum
+dap_chain_cs_dag_event_t * dap_chain_cs_dag_event_new(dap_chain_datum_t * a_datum
                                                 ,dap_enc_key_t * a_key ,
                                                 dap_chain_hash_fast_t * a_hashes, size_t a_hashes_count)
 {
     size_t l_hashes_size = sizeof(*a_hashes)*a_hashes_count;
-    size_t l_datum_size =  dap_chain_datum_data_size(a_datum);
-    size_t l_signs_size = 0;// dap_chain_sign_get_size(a_key);
-    dap_chain_cs_dag_event_t * l_event_new = DAP_NEW_Z_SIZE(dap_chain_cs_dag_event_t,
-                                                         sizeof(l_event_new->header)
-                                                         + l_hashes_size
-                                                         + l_signs_size
-                                                         + l_datum_size
+    size_t l_datum_size =  dap_chain_datum_size(a_datum);
+    dap_chain_cs_dag_event_t * l_event_new = NULL;
+    size_t l_event_size = sizeof(l_event_new->header)
+            + l_hashes_size
+            + l_datum_size;
+    l_event_new = DAP_NEW_Z_SIZE(dap_chain_cs_dag_event_t,
+                                                         l_event_size
                                                          );
     l_event_new->header.timestamp = (uint64_t) timegm(NULL);
-
-    memcpy(l_event_new->hashes_n_signs_n_datum, a_hashes, l_hashes_size );
-
-//    dap_chain_sign_t * l_sign = dap_chain_sign_create(a_key)
-
-//    dap_chain_sign_create(a_key,)
-//    memcpy(l_event_new->hashes_n_signs_n_datum+l_hashes_size, );
-//    a_dag->callback_event_input(a_dag,l_event_new);
-
-}
-
-/**
- * @brief dap_chain_cs_dag_event_delete
- * @param a_dag
- * @param a_event
- */
-void dap_chain_cs_dag_event_delete(dap_chain_cs_dag_t * a_dag,dap_chain_cs_dag_event_t * a_event)
-{
-
-}
-
-
-/**
- * @brief dap_chain_cs_dag_event_get_datum
- * @param a_event
- * @return
- */
-dap_chain_datum_t* dap_chain_cs_dag_event_get_datum(dap_chain_cs_dag_event_t * a_event)
-{
-    uint8_t * l_signs = a_event->hashes_n_signs_n_datum
-            +a_event->header.hash_count*sizeof(dap_chain_hash_fast_t);
-    uint16_t l_signs_offset = 0;
-    uint16_t l_signs_passed;
-    for ( l_signs_passed=0;  l_signs_passed < a_event->header.signs_count; l_signs_passed++){
-        dap_chain_sign_t * l_sign = (dap_chain_sign_t *) l_signs+l_signs_offset;
-        l_signs_offset+=l_sign->header.sign_pkey_size+l_sign->header.sign_size+sizeof(l_sign->header);
+    memcpy(l_event_new->hashes_n_datum_n_signs, a_hashes, l_hashes_size );
+    memcpy(l_event_new->hashes_n_datum_n_signs+l_hashes_size, a_datum,l_datum_size );
+
+    if ( a_key ){
+        dap_chain_sign_t * l_sign = dap_chain_sign_create(a_key,l_event_new,
+                                                          l_hashes_size+  sizeof(l_event_new->header)
+                                                          + l_datum_size ,0);
+        if ( l_sign ){
+            size_t l_sign_size = dap_chain_sign_get_size(l_sign);
+            l_event_new = (dap_chain_cs_dag_event_t* )DAP_REALLOC(l_event_new,l_event_size+l_sign_size );
+            memcpy(l_event_new->hashes_n_datum_n_signs+l_event_size,l_sign,l_sign_size);
+            l_event_size += l_sign_size;
+        }else {
+            log_it(L_ERROR,"Can't sign dag event!");
+            return NULL;
+        }
+    }else {
+        log_it(L_NOTICE, "Created unsigned dag event");
     }
-    return (dap_chain_datum_t*)  l_signs+l_signs_offset;
+    return l_event_new;
 }
 
+
 /**
  * @brief dap_chain_cs_dag_event_get_sign
  * @param a_event
@@ -105,8 +88,8 @@ dap_chain_datum_t* dap_chain_cs_dag_event_get_datum(dap_chain_cs_dag_event_t * a
 dap_chain_sign_t * dap_chain_cs_dag_event_get_sign( dap_chain_cs_dag_event_t * a_event, uint16_t a_sign_number)
 {
     if (a_event->header.signs_count < a_sign_number ){
-        uint8_t * l_signs = a_event->hashes_n_signs_n_datum
-                +a_event->header.hash_count*sizeof(dap_chain_hash_fast_t);
+        size_t l_offset_to_sign = dap_chain_cs_dag_event_calc_size_excl_signs(a_event);
+        uint8_t * l_signs = ((uint8_t*) a_event)+l_offset_to_sign;
         uint16_t l_signs_offset = 0;
         uint16_t l_signs_passed;
         for ( l_signs_passed=0;  l_signs_passed < a_sign_number; l_signs_passed++){

dap_chain_cs_dag_event.h

@@ -32,25 +32,33 @@
 typedef struct dap_chain_cs_dag dap_chain_cs_dag_t;
 
 typedef struct dap_chain_class_dag_event_hdr {
-        uint8_t version;
+        uint16_t version;
         uint64_t timestamp;
         uint16_t hash_count; // Number of hashes
         uint16_t signs_count; // Number of signs nested with event
-} dap_chain_class_dag_event_hdr_t;
+} DAP_ALIGN_PACKED dap_chain_class_dag_event_hdr_t;
 
 typedef struct dap_chain_cs_dag_event {
     dap_chain_class_dag_event_hdr_t header;
-    uint8_t hashes_n_signs_n_datum[]; // Hashes, signes and datum
-} dap_chain_cs_dag_event_t;
+    uint8_t hashes_n_datum_n_signs[]; // Hashes, signes and datum
+} DAP_ALIGN_PACKED dap_chain_cs_dag_event_t;
 
 
-dap_chain_cs_dag_event_t * dap_chain_cs_dag_event_new(dap_chain_cs_dag_t * a_dag, dap_chain_datum_t * a_datum,
+dap_chain_cs_dag_event_t * dap_chain_cs_dag_event_new(dap_chain_datum_t * a_datum,
                                                 dap_enc_key_t * a_key,
                                                 dap_chain_hash_fast_t * a_hashes, size_t a_hashes_count);
 
-void dap_chain_cs_dag_event_delete(dap_chain_cs_dag_t * a_dag, dap_chain_cs_dag_event_t * a_event);
+/**
+ * @brief dap_chain_cs_dag_event_get_datum
+ * @param a_event
+ * @return
+ */
+static inline dap_chain_datum_t* dap_chain_cs_dag_event_get_datum(dap_chain_cs_dag_event_t * a_event)
+{
+    return (dap_chain_datum_t* ) a_event->hashes_n_datum_n_signs
+            +a_event->header.hash_count*sizeof(dap_chain_hash_fast_t);
+}
 
-dap_chain_datum_t* dap_chain_cs_dag_event_get_datum(dap_chain_cs_dag_event_t * a_event);
 dap_chain_sign_t * dap_chain_cs_dag_event_get_sign( dap_chain_cs_dag_event_t * a_event, uint16_t a_sign_number);
 
 /**
@@ -61,20 +69,32 @@ dap_chain_sign_t * dap_chain_cs_dag_event_get_sign( dap_chain_cs_dag_event_t * a
 static inline size_t dap_chain_cs_dag_event_calc_size(dap_chain_cs_dag_event_t * a_event)
 {
     size_t l_hashes_size = a_event->header.hash_count*sizeof(dap_chain_hash_fast_t);
-    uint8_t * l_signs = a_event->hashes_n_signs_n_datum
-            +l_hashes_size;
+    dap_chain_datum_t * l_datum = (dap_chain_datum_t*) a_event->hashes_n_datum_n_signs + l_hashes_size;
+
+    size_t l_datum_size = dap_chain_datum_size(l_datum);
+    uint8_t * l_signs = a_event->hashes_n_datum_n_signs
+            +l_hashes_size+l_datum_size;
     uint16_t l_signs_offset = 0;
     uint16_t l_signs_passed;
     for ( l_signs_passed=0;  l_signs_passed < a_event->header.signs_count; l_signs_passed++){
         dap_chain_sign_t * l_sign = (dap_chain_sign_t *) l_signs+l_signs_offset;
         l_signs_offset+=l_sign->header.sign_pkey_size+l_sign->header.sign_size+sizeof(l_sign->header);
     }
-    dap_chain_datum_t * l_datum = (dap_chain_datum_t*)  l_signs+l_signs_offset;
-    return sizeof( a_event->header ) + l_hashes_size +l_signs_offset +l_datum->header.data_size;
+
+    return sizeof( a_event->header ) + l_hashes_size +l_signs_offset +l_datum_size;
+}
+
+static inline size_t dap_chain_cs_dag_event_calc_size_excl_signs(dap_chain_cs_dag_event_t * a_event)
+{
+    size_t l_hashes_size = a_event->header.hash_count*sizeof(dap_chain_hash_fast_t);
+    dap_chain_datum_t * l_datum = (dap_chain_datum_t*) a_event->hashes_n_datum_n_signs + l_hashes_size;
+    size_t l_datum_size = dap_chain_datum_size(l_datum);
+    return  l_hashes_size + sizeof (a_event->header)+l_datum_size;
 }
 
 /**
  * @brief dap_chain_cs_dag_event_calc_hash
+ * @details Important moment, it calculates hash of everything except signatures
  * @param a_event
  * @param a_event_hash
  */