Queue implementation

CMakeLists.txt

@@ -13,6 +13,8 @@ set(INCLUDE_TX "" CACHE INTERNAL "used internally")
 set(INCLUDE_BLOCK "" CACHE INTERNAL "used internally")
 set(INCLUDE_GLOBAL "" CACHE INTERNAL "used internally")
 set(INCLUDE_TEST "" CACHE INTERNAL "used internally")
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+find_package(Threads REQUIRED)
 
 set(UTHASH_IN_PROJ "src/includes/uthash/")
 set(INCLUDE_ALL 

src/core/blocks/base_block.c

@@ -3,6 +3,7 @@
 #include <string.h>
 
 #include "base_block.h"
+#include "base_tx.h"
 #include "ser_block.h"
 #include "crypto.h"
 
@@ -56,3 +57,15 @@ void pretty_print_block(Block *block, char *prefix){
     printf(LINE_BREAK);
   }
 }
+
+void free_block(Block *block){
+  if(block != NULL){
+    if(block->txs != NULL){
+      for(unsigned int i = 0; i < block->num_txs; i++ ){
+        free_tx(block->txs[i]);
+      }
+      free(block->txs);
+    }
+    free(block);
+  }
+}

src/core/globals/init_globals.c

@@ -4,11 +4,14 @@
 #include "utxo_pool.h"
 #include "mempool.h"
 #include "init_db.h"
+#include "wallet_pool.h"
 
 void node_init(char *db_env) {
   // Read from file for chain height and top block hash
   blockchain_init_leveldb(db_env);
   utxo_pool_init_leveldb(db_env);
+  wallet_init_leveldb(db_env);
+  mempool_init();
 }
 
 void miner_init() {

src/core/txs/handle_tx.c

@@ -4,7 +4,8 @@
 #include "utxo_to_tx.h"
 
 int handle_tx(Transaction *tx){
-  if(mempool_add(tx) == NULL){
+  Transaction *coppied_tx = copy_tx(tx);
+  if(mempool_add(coppied_tx) == NULL){
     return 1;
   }
   return 0;

src/core/utils/CMakeLists.txt

@@ -8,4 +8,10 @@ target_link_libraries(crypto
 add_library(init_db STATIC init_db.c)
 target_include_directories(init_db PUBLIC ${INCLUDE_ALL})
 target_link_libraries(init_db
-  leveldb)
+  leveldb)
+
+add_library(queue STATIC queue.c)
+target_include_directories(queue PUBLIC ${INCLUDE_ALL})
+target_link_libraries(queue
+  core_tx
+  core_block)

src/core/utils/queue.c

@@ -0,0 +1,73 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <semaphore.h>
+#include "pthread.h"
+#include "queue.h"
+#include "base_tx.h"
+#include "base_block.h"
+#include <unistd.h>
+
+Queue *queue_init(){
+  Queue *new_q = malloc(sizeof(Queue));
+  new_q->head = NULL;
+  new_q->tail = NULL;
+  //INitialize sepmaphores and lock
+  sem_init(&new_q->sem_len, 0, 0);
+  if (pthread_mutex_init(&new_q->lock, NULL) != 0) {
+      printf("\n mutex init has failed\n");
+      return NULL;
+  }
+  //pthread_mutex_unlock(&new_q->lock);
+  return new_q;
+}
+
+void queue_destroy(Queue *existing_q){
+  pthread_mutex_lock(&existing_q->lock); // Maybe we don't need to lock if we are destroying?
+  pthread_mutex_destroy(&existing_q->lock);
+  QueueItem *cur_item = existing_q->head;
+  QueueItem *next_item = NULL;
+  while(cur_item != NULL){
+    next_item = cur_item->next;
+    free(cur_item);
+    cur_item = next_item;
+  }
+  free(existing_q);
+}
+
+int queue_add_void(Queue *existing_q, void *new_item){
+  pthread_mutex_lock(&existing_q->lock);
+  QueueItem *new_entry = malloc(sizeof(QueueItem));
+  new_entry->item = new_item;
+  new_entry->next = NULL;
+  if(!existing_q->tail && !existing_q->head){
+    existing_q->tail = new_entry;
+    existing_q->head = new_entry;
+  }
+  else{
+    existing_q->tail->next = new_entry;
+    existing_q->tail = new_entry;
+  }
+  pthread_mutex_unlock(&existing_q->lock);
+  int ret = sem_post(&existing_q->sem_len); 
+  return 0;
+}
+
+void *queue_pop_void(Queue *existing_q){
+  sem_wait(&existing_q->sem_len);
+  pthread_mutex_lock(&existing_q->lock);
+  if(!existing_q->head){
+    fprintf(stderr, "Popping off empty Queue");
+    exit(1);
+  }
+
+  QueueItem *popped_item = existing_q->head;
+  existing_q->head = existing_q->head->next;
+  // Check to see if tail should be set to Null
+  if(!existing_q->head){
+    existing_q->tail = NULL;
+  }
+  void *ret = popped_item->item;
+  free(popped_item);
+  pthread_mutex_unlock(&existing_q->lock);
+  return ret;
+}

src/includes/blocks/base_block.h

@@ -22,6 +22,13 @@ typedef struct Block{
  */
 void hash_blockheader(unsigned char *dest, BlockHeader *header);
 
+/**
+ * @brief Frees a block and it's containing transactions safely
+ * 
+ * @param block to free
+ */
+void free_block(Block *block);
+
 /*
 Prints a Block Header to stdout so data can be visualized
 

src/includes/globals/constants.h

@@ -10,7 +10,7 @@
 #define ERR_BUF 1024
 #define BLOCK_REWARD 100
 #define DESIRED_NUM_TX 10
-#define HASH_DIFFICULTY 2
+#define HASH_DIFFICULTY 3
 #define MINING_NODE 1
 #define WALLET_NODE 1
 

src/includes/utils/queue.h

@@ -0,0 +1,26 @@
+#pragma once
+#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include "base_tx.h"
+#include "base_block.h"
+
+typedef struct QueueItem{
+  void *item;
+  struct QueueItem *next;
+} QueueItem;
+
+typedef struct Queue {
+  QueueItem *head;
+  QueueItem *tail;
+  pthread_mutex_t lock;
+  sem_t sem_len;
+} Queue;
+
+Queue *queue_init();
+
+void queue_destroy(Queue *exisiting_q);
+
+int queue_add_void(Queue *existing_q, void *new_item);
+void *queue_pop_void(Queue *existing_q);

src/runtime/CMakeLists.txt

@@ -4,7 +4,7 @@ message(STATUS "Building Runtime")
 # Add inlcudes for the runtime headers
 add_subdirectory(includes)
 
-add_executable(shell shell.c)
+add_library(shell shell.c)
 target_compile_options(shell PRIVATE ${COMPILE_OPTIONS_STD})
 target_include_directories(shell PUBLIC
   ${INCLUDE_ALL}
@@ -14,3 +14,15 @@ target_link_libraries(shell
   wallet
   handle_block
   init_globals)
+
+add_executable(runtime runtime.c)
+target_compile_options(runtime PRIVATE ${COMPILE_OPTIONS_STD})
+target_include_directories(runtime PUBLIC ${INCLUDE_ALL})
+target_link_libraries(runtime
+  queue
+  handle_block
+  Threads::Threads
+  init_globals
+  validate_tx
+  handle_tx
+  shell)

src/runtime/includes/runtime.h

@@ -0,0 +1,17 @@
+#pragma once
+#include "queue.h"
+#include "pthread.h"
+#include "semaphore.h"
+
+typedef struct Globals {
+  Queue *queue_block;
+  Queue *queue_tx;
+  pthread_mutex_t utxo_pool_lock;
+  pthread_mutex_t utxo_to_tx_lock;
+  pthread_mutex_t blockchain_lock;
+  pthread_mutex_t wallet_pool_lock;
+  pthread_mutex_t key_pool_lock;
+  pthread_mutex_t mempool_lock;
+  int *miner_update;
+  pthread_mutex_t miner_update_lock;
+} Globals;

src/runtime/includes/shell.h

@@ -16,12 +16,13 @@
 #pragma once
 
 #include <uthash.h>
+#include "runtime.h"
 
 #define COMMAND_NAME_LEN 128
 
 typedef struct {
   char *name;
-  int (*func)(char **);
+  int (*func)(Globals *, char **);
   size_t num_args;
   char *help;
 } Command;
@@ -37,17 +38,17 @@ void str_to_buf(
     size_t dest_len, size_t src_len
 );
 
-int shell_mine(char **args);
-int shell_build_tx(char **args);
-int shell_print_chain(char **args);
-int shell_print_block(char **args);
-int shell_exit(char **args);
-int shell_help(char **args);
+int shell_mine(Globals *globals, char **args);
+int shell_build_tx(Globals *globals, char **args);
+int shell_print_chain(Globals *globals, char **args);
+int shell_print_block(Globals *globals, char **args);
+int shell_exit(Globals *globals, char **args);
+int shell_help(Globals *globals, char **args);
 
 char *shell_read_line();
 char **shell_tokenize(char *line);
-int shell_execute(size_t num_args, char **args);
-void shell_loop();
+int shell_execute(Globals *globals, size_t num_args, char **args);
+void shell_loop(Globals *globals);
 
 void shell_init_globals();
 void shell_init_commands();