Fix memory allocation on some queries

Updated to latest simapi for tyre compound mapping on Assetto Corsa
Fix formatting on new code
2024-02-03 12:55:54 -05:00 · 2024-01-30 18:29:24 -05:00 · 2024-01-25 03:49:15 +00:00 · 2024-01-25 03:46:28 +00:00 · 2024-01-24 18:33:35 +00:00 · 2024-01-20 13:57:05 -05:00
17 changed files with 1778 additions and 1327 deletions
@@ -1,6 +1,12 @@
 set(gameloop_source_files
  gameloop.c
  gameloop.h
+  browseloop.c
+  browseloop.h
+  hoeldb.h
+  hoeldb.c
+  telemetry.h
+  telemetry.c
 )


@@ -1,4 +1,4 @@
 #include "../helper/parameters.h"
 #include "../helper/confighelper.h"

-int browseloop(Parameters* p);
+int browseloop(Parameters* p, char* datadir);
@@ -13,6 +13,8 @@
 #include <hoel.h>
 #include <jansson.h>

+#include "hoeldb.h"
+#include "telemetry.h"
 #include "gameloop.h"
 #include "../helper/parameters.h"
 #include "../helper/confighelper.h"
@@ -107,7 +109,7 @@ int curses_init()
    box(win4, 0, 0);
 }

-char * removeSpacesFromStr(char *string)
+char* removeSpacesFromStr(char* string)
 {
    int non_space_count = 0;

@@ -127,7 +129,7 @@ char * removeSpacesFromStr(char *string)
 void update_date()
 {
    time_t rawtime;
-    struct tm * timeinfo;
+    struct tm* timeinfo;
    time ( &rawtime );
    timeinfo = localtime ( &rawtime );
    sprintf(datestring, "%.24s", asctime (timeinfo));
@@ -163,13 +165,10 @@ int mainloop(Parameters* p)
    while (go == true)
    {

-
-
-
        getSim(simdata, simmap, &p->simon, &p->sim);

-
-        if (p->simon == true) {
+        if (p->simon == true && simdata->simstatus > 1)
+        {
            p->program_state = 1;
            if (p->cli == true)
            {
@@ -308,7 +307,7 @@ void* looper(void* thargs)

    int go = true;
    char lastsimstatus = false;
-    while (go == true)
+    while (go == true && simdata->simstatus > 1)
    {
        simdatamap(simdata, simmap, p->sim);

@@ -317,7 +316,8 @@ void* looper(void* thargs)
        wclear(win3);
        wclear(win4);

-        { // window 1 car diagnostics
+        {
+            // window 1 car diagnostics

            char spacer[14];
            sprintf(spacer, "\n");
@@ -472,7 +472,8 @@ void* looper(void* thargs)
            rectangle(18, 18, 22, 22); // right rear
        }

-        { // window 2 session info
+        {
+            // window 2 session info

            char spacer[14];
            sprintf(spacer, "\n");
@@ -535,7 +536,8 @@ void* looper(void* thargs)
            wattrset(win2, COLOR_PAIR(1));
        }

-        { // window 3 basic timing and scoring
+        {
+            // window 3 basic timing and scoring

            char spacer[14];
            sprintf(spacer, "\n");
@@ -600,7 +602,8 @@ void* looper(void* thargs)
            wattrset(win3, COLOR_PAIR(1));
        }

-        { // window 4 live standings timing and scoring
+        {
+            // window 4 live standings timing and scoring
            char spacer[14];
            sprintf(spacer, "\n");
            waddstr(win4, spacer);
@@ -635,7 +638,9 @@ void* looper(void* thargs)
                for(i=0; i<displaycars; i++)
                {
                    if((ihold+1)==simdata->cars[i].pos)
+                    {
                        break;
+                    }
                }

                wattrset(win4, COLOR_PAIR(2));
@@ -665,8 +670,8 @@ void* looper(void* thargs)

                if(simdata->cars[i].inpitlane == 0 && simdata->cars[i].inpit == 0)
                {
-                wattrset(win4, COLOR_PAIR(1));
-                wprintw(win4, "  ontrack  ");
+                    wattrset(win4, COLOR_PAIR(1));
+                    wprintw(win4, "  ontrack  ");
                }
                else
                {
@@ -721,448 +726,6 @@ void* looper(void* thargs)
    //return 0;
 }

-int getLastInsertID(struct _h_connection* conn)
-{
-    json_t* last_id = (h_last_insert_id(conn));
-    int id = json_integer_value(last_id);
-    json_decref(last_id);
-    return id;
-}
-
-int adddriver(struct _h_connection* conn, int driverid, const char* drivername)
-{
-    if (driverid > 0)
-    {
-        return driverid;
-    }
-    json_t *root = json_object();
-    json_t *json_arr = json_array();
-
-    json_object_set_new( root, "table", json_string("drivers") );
-    json_object_set_new( root, "values", json_arr );
-
-    json_t* values = json_object();
-    json_object_set_new(values, "driver_name", json_string(drivername));
-    json_object_set_new(values, "prev_name", json_string(drivername));
-    json_object_set_new(values, "steam64_id", json_integer(17));
-    json_object_set_new(values, "country", json_string("USA"));
-    json_array_append(json_arr, values);
-    int res = h_insert(conn, root, NULL);
-    json_decref(root);
-    json_decref(values);
-
-    driverid = getLastInsertID(conn);
-    return driverid;
-}
-
-int addtrackconfig(struct _h_connection* conn, int trackconfigid, const char* track, int length)
-{
-    //track_config_id | track_name | config_name | display_name | country | city | length
-    if (trackconfigid > 0)
-    {
-        return trackconfigid;
-    }
-    json_t *root = json_object();
-    json_t *json_arr = json_array();
-
-    json_object_set_new( root, "table", json_string(track) );
-    json_object_set_new( root, "values", json_arr );
-
-    json_t* values = json_object();
-    json_object_set_new(values, "track_name", json_string(track));
-    json_object_set_new(values, "config_name", json_string("default"));
-    json_object_set_new(values, "display_name", json_string(track));
-    json_object_set_new(values, "country", json_string("USA"));
-    json_object_set_new(values, "city", json_string("USA"));
-    json_object_set_new(values, "length", json_integer(length));
-
-    json_array_append(json_arr, values);
-    int res = h_insert(conn, root, NULL);
-    trackconfigid = getLastInsertID(conn);
-    json_decref(root);
-    json_decref(values);
-
-    return trackconfigid;
-}
-
-int addevent(struct _h_connection* conn, int track_config)
-{
-
-    json_t *root = json_object();
-    json_t *json_arr = json_array();
-
-    json_object_set_new( root, "table", json_string("events") );
-    json_object_set_new( root, "values", json_arr );
-
-    json_t* values = json_object();
-    json_object_set_new(values, "track_config_id", json_integer(track_config));
-    json_object_set_new(values, "event_name", json_string("default"));
-    //event_id | server_name | track_config_id | event_name | team_event | active | livery_preview | use_number | practice_duration | quali_duration | race_duration | race_duration_type | race_wait_time | race_extra_laps | reverse_grid_positions
-    json_array_append(json_arr, values);
-    int res = h_insert(conn, root, NULL);
-    json_decref(root);
-    json_decref(values);
-    return getLastInsertID(conn);
-}
-
-int addsession(struct _h_connection* conn, int eventid, int eventtype, int airtemp, int tracktemp)
-{
-
-// session_id | event_id | event_type | track_time | session_name
-// | start_time | duration_min | elapsed_ms | laps | weather |
-// air_temp | road_temp | start_grip |
-    json_t *root = json_object();
-    json_t *json_arr = json_array();
-
-    json_object_set_new( root, "table", json_string("sessions") );
-    json_object_set_new( root, "values", json_arr );
-
-    json_t* values = json_object();
-    json_object_set_new(values, "event_id", json_integer(eventid));
-    json_object_set_new(values, "event_type", json_integer(1));
-    json_object_set_new(values, "duration_min", json_integer(60));
-    json_object_set_new(values, "start_time", json_string("NOW()"));
-    json_object_set_new(values, "session_name", json_string("default"));
-    json_object_set_new(values, "air_temp", json_integer(airtemp));
-    json_object_set_new(values, "road_temp", json_integer(tracktemp));
-    json_object_set_new(values, "weather", json_string("Windy"));
-    json_object_set_new(values, "http_port", json_integer(0));
-    json_array_append(json_arr, values);
-    int res = h_insert(conn, root, NULL);
-    slogt("session insert response: %i", res);
-    json_decref(root);
-    json_decref(values);
-    return getLastInsertID(conn);
-}
-
-int addstint(struct _h_connection* conn, int sessionid, int driverid, int carid)
-{
-
-
-    json_t *root = json_object();
-    json_t *json_arr = json_array();
-
-    json_object_set_new( root, "table", json_string("stints") );
-    json_object_set_new( root, "values", json_arr );
-
-    json_t* values = json_object();
-
-    json_object_set_new(values, "driver_id", json_integer(driverid));
-    //team_member_id
-    json_object_set_new(values, "session_id", json_integer(sessionid));
-    json_object_set_new(values, "car_id", json_integer(carid));
-    json_object_set_new(values, "game_car_id", json_integer(carid));
-    json_object_set_new(values, "laps", json_integer(0));
-    json_object_set_new(values, "valid_laps", json_integer(0));
-    // best_lap_id
-    json_object_set_new(values, "is_finished", json_integer(0));
-
-    json_object_set_new(values, "started_at", json_string("NOW()") );
-    json_array_append(json_arr, values);
-    int res = h_insert(conn, root, NULL);
-    slogt("stint insert response: %i", res);
-    json_decref(root);
-    json_decref(values);
-    return getLastInsertID(conn);
-}
-
-int closesession(struct _h_connection* conn, int sessionid)
-{
-
-    slogt("closing previous session ", sessionid);
-// best_lap_id
-
-// session_id | event_id | event_type | track_time | session_name
-// | start_time | duration_min | elapsed_ms | laps | weather |
-// air_temp | road_temp | start_grip | end_grip | is_finished
-
-    char* query = malloc((sizeof(char)*100));
-    sprintf(query, "UPDATE %s SET is_finished=1, finished_at=NOW() WHERE session_id=%i",
-            "sessions", sessionid);
-
-    int res1 = h_query_update(conn, query);
-    slogt("running query %s", query);
-    free(query);
-
-    slogt("closed previous session");
-    return res1;
-}
-
-
-int closestint(struct _h_connection* conn, int stintid, int stintlaps, int validstintlaps)
-{
-
-// best_lap_id
-    slogt("closing previous stint ", stintid);
-
-    char* query = malloc((sizeof(char)*146));
-    sprintf(query, "UPDATE %s SET %s = %i, %s = %i, is_finished=1, finished_at=NOW() WHERE stint_id=%i",
-            "stints", "laps", stintlaps, "valid_laps", validstintlaps, stintid);
-
-    int res1 = h_query_update(conn, query);
-    slogt("running query %s", query);
-    free(query);
-
-    slogt("closed previous stint");
-    return res1;
-}
-
-int closelap(struct _h_connection* conn, int lapid, int sector1, int sector2, int sector3, int cuts, int crashes, int maxspeed, int avgspeed,
-    double fbraketemp, double rbraketemp, double ftyrewear, double rtyrewear, double ftyretemp, double rtyretemp, double ftyrepress, double rtyrepress)
-{
-
-// stint laps
-// lap_id | stint_id | sector_1 | sector_2 | sector_3 | grip | tyre | time | cuts | crashes
-// max_speed | avg_speed | finished_at
-
-    slogt("closing previous lap ", lapid);
-
-    char* query = malloc((sizeof(char)*360));
-    sprintf(query, "UPDATE %s SET %s=%i, %s=%i, %s=%i, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, finished_at=NOW() WHERE lap_id=%i;",
-        "laps", "sector_1", sector1, "sector_2", sector2, "sector_3", sector3, "front_tyre_temp", ftyretemp, "rear_tyre_temp", rtyretemp,
-        "front_tyre_wear", ftyrewear, "rear_tyre_wear", rtyrewear, "front_tyre_press", ftyrepress, "rear_tyre_press", rtyrepress,
-        "front_brake_temp", fbraketemp, "rear_brake_temp", rbraketemp, lapid);
-
-
-    int res1 = h_query_update(conn, query);
-    slogt("running query %s", query);
-    free(query);
-
-    slogt("closed previous lap");
-    return res1;
-}
-
-
-int addstintlap(struct _h_connection* conn, int stintid)
-{
-
-// stint laps
-// stint_lap_id | stint_id | sector_1 | sector_2 | sector_3 | grip | tyre | time | cuts | crashes
-// max_speed | avg_speed | finished_at
-    json_t *root = json_object();
-    json_t *json_arr = json_array();
-
-    json_object_set_new( root, "table", json_string("laps") );
-    json_object_set_new( root, "values", json_arr );
-
-    json_t* values = json_object();
-
-    json_object_set_new(values, "stint_id", json_integer(stintid));
-    json_object_set_new(values, "tyre", json_string("Vintage") );
-    json_array_append(json_arr, values);
-    int res = h_insert(conn, root, NULL);
-    slogt("stint lap insert response: %i", res);
-    json_decref(root);
-    json_decref(values);
-    return getLastInsertID(conn);
-}
-
-int addcar(struct _h_connection* conn, int carid, const char* carname)
-{
-
-    // car_id | display_name | car_name | manufacturer | car_class
-
-    if (carid > 0)
-    {
-        return carid;
-    }
-    json_t *root = json_object();
-    json_t *json_arr = json_array();
-
-    json_object_set_new( root, "table", json_string("cars") );
-    json_object_set_new( root, "values", json_arr );
-
-    json_t* values = json_object();
-    json_object_set_new(values, "display_name", json_string(carname));
-    json_object_set_new(values, "car_name", json_string(carname));
-    json_object_set_new(values, "manufacturer", json_string("Unknown"));
-    json_object_set_new(values, "car_class", json_string("Unknown"));
-    json_array_append(json_arr, values);
-    int res = h_insert(conn, root, NULL);
-    json_decref(root);
-    json_decref(values);
-
-    carid = getLastInsertID(conn);
-    return carid;
-}
-
-int addtelemetry(struct _h_connection* conn, int points, int stintid)
-{
-
-    json_t *root = json_object();
-    json_t *json_arr = json_array();
-
-    json_object_set_new( root, "table", json_string("telemetry") );
-    json_object_set_new( root, "values", json_arr );
-
-    json_t* values = json_object();
-    json_object_set_new(values, "lap_id", json_integer(stintid));
-    json_object_set_new(values, "points", json_integer(points));
-    json_array_append(json_arr, values);
-    int res = h_insert(conn, root, NULL);
-    json_decref(root);
-    json_decref(values);
-
-    int telemid = getLastInsertID(conn);
-    return telemid;
-}
-
-int updatetelemetry(struct _h_connection* conn, int telemid, int size, const char* column, void* data)
-{
-
-    //char *pp = malloc((size*2)+1);
-    char output[(size * 2) + 1];
-    char *ppp = &output[0];
-    unsigned char *p = data;
-    int i;
-    for (i=0; i<size; i++) {
-        ppp += sprintf(ppp, "%02hhX", p[i]);
-        //snprintf(pp, (size*2)+1, "%s%02hhX", pp, p[i]);
-    }
-
-    char* query = malloc((sizeof(char)*71)+(sizeof(column))+(size*2)+1);
-    sprintf(query, "UPDATE telemetry SET %s = decode('%s', 'hex') WHERE telemetry_id = %i", column, &output, telemid);
-    int res1 = h_query_update(conn, query);
-    //int res1 = h_insert(conn, j_query, NULL);
-    slogt("got res %i", res1);
-    free(query);
-
-    return res1;
-}
-
-
-int gettrack(struct _h_connection* conn, const char* trackname)
-{
-
-    json_t *j_result;
-    char* where_clause = h_build_where_clause(conn, "config_name=%s AND track_name=%s", "default", trackname);
-    json_t* j_query = json_pack("{sss[s]s{s{ssss}}}", "table", "track_config", "columns", "track_config_id", "where", " ", "operator", "raw",
-            "value", where_clause);
-
-    //char* qq;
-    int res = h_select(conn, j_query, &j_result, NULL);
-    //slogi("here your query: %s", qq);
-  // Deallocate j_query since it won't be needed anymore
-  json_decref(j_query);
-  h_free(where_clause);
-  int track_config = -1;
-  // Test query execution result
-  if (res == H_OK) {
-    // Print result
-    char* dump = json_dumps(j_result, JSON_INDENT(2));
-    slogi("json select result is\n%s", dump);
-    int index1 = json_array_size(j_result);
-    if (index1 == 0)
-    {
-        slogw("no config for this track");
-    }
-    else {
-    json_t* jj = json_array_get(j_result, index1-1);
-    track_config = json_integer_value(json_object_get(jj, "track_config_id"));
-    }
-    // Deallocate data result
-    json_decref(j_result);
-    free(dump);
-  } else {
-    sloge("Error executing select query: %d", res);
-  }
-  return track_config;
-}
-
-int getdriver(struct _h_connection* conn, const char* driver_name)
-{
-    json_t *j_result;
-    char* where_clause = h_build_where_clause(conn, "driver_name=%s", driver_name);
-    json_t* j_query = json_pack("{sss[s]s{s{ssss}}}","table", "drivers", "columns", "driver_id", "where", " ", "operator", "raw",
-            "value", where_clause);
-
-    slogi("Looking for driver named %s", driver_name);
-    //char* qq;
-    int res = h_select(conn, j_query, &j_result, NULL);
-    //slogi("here your query: %s", qq);
-  // Deallocate j_query since it won't be needed anymore
-  json_decref(j_query);
-  h_free(where_clause);
-  int driver_id = -1;
-  // Test query execution result
-  if (res == H_OK) {
-    // Print result
-    char* dump = json_dumps(j_result, JSON_INDENT(2));
-    slogi("json select result is\n%s", dump);
-    int index1 = json_array_size(j_result);
-    if (index1 == 0)
-    {
-        slogw("no driver by this name");
-    }
-    else {
-    json_t* jj = json_array_get(j_result, index1-1);
-    driver_id = json_integer_value(json_object_get(jj, "driver_id"));
-    }
-    // Deallocate data result
-    json_decref(j_result);
-    free(dump);
-  } else {
-    sloge("Error executing select query: %d", res);
-  }
-  return driver_id;
-}
-
-int getcar(struct _h_connection* conn, const char* carname)
-{
-    json_t *j_result;
-    char* where_clause = h_build_where_clause(conn, "car_name=%s", carname);
-    json_t* j_query = json_pack("{sss[s]s{s{ssss}}}","table", "cars", "columns", "car_id", "where", " ", "operator", "raw",
-            "value", where_clause);
-
-    slogi("Looking for car named %s", carname);
-    //char* qq;
-    int res = h_select(conn, j_query, &j_result, NULL);
-    //slogi("here your query: %s", qq);
-  // Deallocate j_query since it won't be needed anymore
-  json_decref(j_query);
-  h_free(where_clause);
-  int car_id = -1;
-  // Test query execution result
-  if (res == H_OK) {
-    // Print result
-    char* dump = json_dumps(j_result, JSON_INDENT(2));
-    slogi("json select result is\n%s", dump);
-    int index1 = json_array_size(j_result);
-    if (index1 == 0)
-    {
-        slogw("no car by this name");
-    }
-    else {
-    json_t* jj = json_array_get(j_result, index1-1);
-    car_id = json_integer_value(json_object_get(jj, "car_id"));
-    }
-    // Deallocate data result
-    json_decref(j_result);
-    free(dump);
-  } else {
-    sloge("Error executing select query: %d", res);
-  }
-  return car_id;
-}
-
-void print_bytes(void *ptr, int size)
-{
-    char *pp = malloc((size*2)+1);
-    char output[(size * 2) + 1];
-    char *ppp = &output[0];
-    unsigned char *p = ptr;
-    int i;
-    for (i=0; i<size; i++) {
-        slogt("%02hhX", p[i]);
-        ppp += sprintf(ppp, "%02X", p[i]);
-        //snprintf(pp, (size*2)+1, "%s%02hhX", pp, p[i]);
-    }
-    slogt("\n");
-    slogt("bytes %s", output);
-}
-
-
-
 void* simviewmysql(void* thargs)
 {
    Parameters* p = (Parameters*) thargs;
@@ -1170,13 +733,33 @@ void* simviewmysql(void* thargs)
    SimMap* simmap = p->simmap;

    struct _h_result result;
-    struct _h_connection * conn;
-    char* connectionstring = "host=zorak.brak dbname=gilles user=test password=thisisatest";
-    conn = h_connect_pgsql(connectionstring);
+    struct _h_connection* conn;
+    conn = h_connect_pgsql(p->db_conn);

+    if (conn == NULL)
+    {
+        slogf("Unable to connect to configured Gilles database. Are the parameters in the config correct? Is the user allowed to access from this address?");
+        p->err = E_FAILED_DB_CONN;
+        return 0;
+    }
+    slogi("Starting telemetry");

    int trackconfig = gettrack(conn, simdata->track);
+    if (trackconfig == -1)
+    {
+        slogf("Problem performing select query. Does the db user have read permissions?");
+        p->err = E_FAILED_DB_CONN;
+        return 0;
+    }
+
    trackconfig = addtrackconfig(conn, trackconfig, simdata->track, simdata->trackdistancearound);
+    if (trackconfig == -1)
+    {
+        slogf("Problem performing insert query. Does the db user have write permissions?");
+        p->err = E_FAILED_DB_CONN;
+        return 0;
+    }
+    slogt("Detected track configuration id: %i", trackconfig);
    int eventid = addevent(conn, trackconfig);
    int driverid = getdriver(conn, simdata->driver);
    driverid = adddriver(conn, driverid, simdata->driver);
@@ -1197,9 +780,9 @@ void* simviewmysql(void* thargs)
    int stintid = 0;
    int stintlapid = 0;
    int sessionid = 0;
-    sessionid = addsession(conn, eventid, simdata->session, simdata->airtemp, simdata->tracktemp);
-    stintid = addstint(conn, sessionid, driverid, carid);
-    stintlapid = addstintlap(conn, stintid);
+    sessionid = addsession(conn, eventid, carid, simdata->session, simdata->airtemp, simdata->tracktemp, simdata);
+    stintid = addstint(conn, sessionid, driverid, carid, simdata);
+    stintlapid = addstintlap(conn, stintid, simdata);
    sessionstatus = simdata->session;
    lastsessionstatus = sessionstatus;
    lap = simdata->lap;
@@ -1214,7 +797,7 @@ void* simviewmysql(void* thargs)
    int track_samples = simdata->trackspline / TRACK_SAMPLE_RATE;
    slogt("track samples %i", track_samples);

-    int stintlaps = 0;
+    int stintlaps = 1;
    int validstintlaps = 0;
    bool validind = true;

@@ -1225,18 +808,6 @@ void* simviewmysql(void* thargs)
    double* acceldata = malloc(track_samples * sizeof(simdata->gas));
    double* brakedata = malloc(track_samples * sizeof(simdata->brake));

-    //double* tyretemp0 = malloc(track_samples * sizeof(simdata->tyretemp[0]));
-    //double* tyretemp1 = malloc(track_samples * sizeof(simdata->tyretemp[0]));
-    //double* tyretemp2 = malloc(track_samples * sizeof(simdata->tyretemp[0]));
-    //double* tyretemp3 = malloc(track_samples * sizeof(simdata->tyretemp[0]));
-    //double* tyrepressure0 = malloc(track_samples * sizeof(simdata->tyrepressure[0]));
-    //double* tyrepressure1 = malloc(track_samples * sizeof(simdata->tyrepressure[0]));
-    //double* tyrepressure2 = malloc(track_samples * sizeof(simdata->tyrepressure[0]));
-    //double* tyrepressure3 = malloc(track_samples * sizeof(simdata->tyrepressure[0]));
-    //double* braketemp0 = malloc(track_samples * sizeof(simdata->braketemp[0]));
-    //double* braketemp1 = malloc(track_samples * sizeof(simdata->braketemp[0]));
-    //double* braketemp2 = malloc(track_samples * sizeof(simdata->braketemp[0]));
-    //double* braketemp3 = malloc(track_samples * sizeof(simdata->braketemp[0]));
    int sectortimes[4];

    if (p->program_state < 0)
@@ -1259,19 +830,6 @@ void* simviewmysql(void* thargs)
        geardata[pos] = simdata->gear;


-        //tyretemp0[pos] = simdata->tyretemp[0];
-        //tyretemp1[pos] = simdata->tyretemp[1];
-        //tyretemp2[pos] = simdata->tyretemp[2];
-        //tyretemp3[pos] = simdata->tyretemp[3];
-        //tyrepressure0[pos] = simdata->tyrepressure[0];
-        //tyrepressure1[pos] = simdata->tyrepressure[1];
-        //tyrepressure2[pos] = simdata->tyrepressure[2];
-        //tyrepressure3[pos] = simdata->tyrepressure[3];
-        //braketemp0[pos] = simdata->braketemp[0];
-        //braketemp1[pos] = simdata->braketemp[1];
-        //braketemp2[pos] = simdata->braketemp[2];
-        //braketemp3[pos] = simdata->braketemp[3];
-


        sessionstatus = simdata->session;
@@ -1288,25 +846,25 @@ void* simviewmysql(void* thargs)
            closesession(conn, sessionid);
            if (sessionstatus > 1)
            {
-                sessionid = addsession(conn, eventid, simdata->session, simdata->airtemp, simdata->tracktemp);
+                sessionid = addsession(conn, eventid, carid, simdata->session, simdata->airtemp, simdata->tracktemp, simdata);
            }

            //pitstatus = 1;
-            stintlaps = 0;
+            stintlaps = 1;
            validstintlaps = 0;
        }
        pitstatus = simdata->inpit;
        if (simdata->inpit == true && pitstatus != lastpitstatus)
        {
            //pitstatus = 1;
-        //}
-        //if (pitstatus = 0 && pitstatus != lastpitstatus)
-        //{
+            //}
+            //if (pitstatus = 0 && pitstatus != lastpitstatus)
+            //{
            // close last stint

            closestint(conn, stintid, stintlaps, validstintlaps);
-            stintid = addstint(conn, sessionid, driverid, carid);
-            stintlaps = 0;
+            stintid = addstint(conn, sessionid, driverid, carid, simdata);
+            stintlaps = 1;
            validstintlaps = 0;
        }
        if (lap != lastlap)
@@ -1318,26 +876,11 @@ void* simviewmysql(void* thargs)
                validstintlaps++;
            }

-            double fbraketemp = (simdata->braketemp[0] + simdata->braketemp[1])/2;
-            double rbraketemp = (simdata->braketemp[2] + simdata->braketemp[3])/2;
-            double ftyrewear = (simdata->tyrewear[0] + simdata->tyrewear[1])/2;
-            double rtyrewear = (simdata->tyrewear[2] + simdata->tyrewear[3])/2;
-            double ftyretemp = (simdata->tyretemp[0] + simdata->tyretemp[1])/2;
-            double rtyretemp = (simdata->tyretemp[2] + simdata->tyretemp[3])/2;
-            double ftyrepress = (simdata->tyrepressure[0] + simdata->tyrepressure[1])/2;
-            double rtyrepress = (simdata->tyrepressure[2] + simdata->tyrepressure[3])/2;
+            closelap(conn, stintlapid, sectortimes[1], sectortimes[2], simdata->lastsectorinms, 0, 0, 0, 0, simdata);

-            closelap(conn, stintlapid, sectortimes[1], sectortimes[2], simdata->lastsectorinms, 0, 0, 0, 0, fbraketemp, rbraketemp, ftyrewear, rtyrewear, ftyretemp, rtyretemp, ftyrepress, rtyrepress);
-
-            stintlapid = addstintlap(conn, stintid);
+            stintlapid = addstintlap(conn, stintid, simdata);
            int telemid = addtelemetry(conn, track_samples, stintlapid);
-            int b = updatetelemetry(conn, telemid, track_samples*sizeof(double), "steer", steerdata);
-            b = updatetelemetry(conn, telemid, track_samples*sizeof(double), "accel", acceldata);
-            b = updatetelemetry(conn, telemid, track_samples*sizeof(double), "brake", brakedata);
-            b = updatetelemetry(conn, telemid, track_samples*sizeof(int), "rpms", rpmdata);
-            b = updatetelemetry(conn, telemid, track_samples*sizeof(int), "gear", geardata);
-            b = updatetelemetry(conn, telemid, track_samples*sizeof(int), "speed", speeddata);
-
+            int b = updatetelemetrydata(conn, track_samples, telemid, stintlapid, speeddata, geardata, rpmdata, steerdata, acceldata, brakedata);
            tick = 0;
            // assume lap is valid until it isn't
            validind = true;
@@ -1354,6 +897,9 @@ void* simviewmysql(void* thargs)

        if (p->program_state < 0)
        {
+            int telemid = addtelemetry(conn, track_samples, stintlapid);
+            int b = updatetelemetrydata(conn, track_samples, telemid, stintlapid, speeddata, geardata, rpmdata, steerdata, acceldata, brakedata);
+            closelap(conn, stintlapid, sectortimes[1], sectortimes[2], simdata->lastsectorinms, 0, 0, 0, 0, simdata);
            closestint(conn, stintid, stintlaps, validstintlaps);
            closesession(conn, sessionid);
            go = false;
@@ -0,0 +1,676 @@
+#include <stdbool.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <hoel.h>
+#include <jansson.h>
+
+#include "hoeldb.h"
+#include "../simulatorapi/simapi/simapi/simdata.h"
+#include "../helper/confighelper.h"
+#include "../slog/slog.h"
+
+int getLastInsertID(struct _h_connection* conn)
+{
+    json_t* last_id = (h_last_insert_id(conn));
+    int id = json_integer_value(last_id);
+    json_decref(last_id);
+    return id;
+}
+
+void get_row_results(struct _h_result result, DBField* fields, void* rows, size_t rowsize)
+{
+    int col, row, i;
+    char buf[64];
+    //sess->hasdata = true;
+    //sess->rows = result.nb_rows;
+    slogi("rows: %d, col: %d", result.nb_rows, result.nb_columns);
+    char* aaa = (char*) rows;
+    for (row = 0; row<result.nb_rows; row++)
+    {
+
+        char* aa = (char*)aaa + (rowsize * row);
+        for (col=0; col<result.nb_columns; col++)
+        {
+            char* a = (char*) aa + fields[col].offset;
+            switch(result.data[row][col].type)
+            {
+                case HOEL_COL_TYPE_INT:
+                    int bb = ((struct _h_type_int*)result.data[row][col].t_data)->value;
+                    *(int*) a = bb;
+                    break;
+                case HOEL_COL_TYPE_DOUBLE:
+                    double cc = ((struct _h_type_double*)result.data[row][col].t_data)->value;
+                    *(double*) a = cc;
+                    break;
+                case HOEL_COL_TYPE_TEXT:
+                    char* ddd = ((struct _h_type_text*)result.data[row][col].t_data)->value;
+                    memcpy(a, ddd, fields[col].size);
+                    break;
+                case HOEL_COL_TYPE_BLOB:
+                    for (i=0; i<((struct _h_type_blob*)result.data[row][col].t_data)->length; i++)
+                    {
+                        printf("%c", *((char*)(((struct _h_type_blob*)result.data[row][col].t_data)->value+i)));
+                        if (i%80 == 0 && i>0)
+                        {
+                            printf("\n");
+                        }
+                    }
+                    break;
+                case HOEL_COL_TYPE_DATE:
+                    strftime(a, fields[col].size, "%Y-%m-%d %H:%M:%S", &((struct _h_type_datetime*)result.data[row][col].t_data)->value);
+                    //strftime(buf, 64, "%Y-%m-%d %H:%M:%S", &((struct _h_type_datetime *)result.data[row][col].t_data)->value);
+                    printf("| %s ", buf);
+                case HOEL_COL_TYPE_NULL:
+                    printf("| [null] ");
+                    break;
+            }
+        }
+        printf("|\n");
+    }
+}
+
+int getsessions(struct _h_connection* conn, const char* sessionname, SessionDbo* sess)
+{
+    struct _h_result result;
+    struct _h_data* data;
+    char* query = malloc(515 * sizeof(char));
+    slogt("Performing query sessions");
+
+    sprintf(query, "select sessions.session_id, events.event_id, sessions.event_type, table1.stints, track_config.display_name, cars.car_name, start_time "
+            "FROM %s JOIN events ON sessions.event_id=events.event_id JOIN track_config ON events.track_config_id=track_config.track_config_id "
+            "JOIN cars ON sessions.car_id=cars.car_id "
+            "JOIN (Select session_id, COUNT(stint_id) AS stints FROM stints GROUP BY session_id) AS table1 ON table1.session_id=sessions.session_id "
+            "ORDER BY session_id DESC LIMIT 25", "Sessions");
+
+    int errcode = h_query_select(conn, query, &result);
+    if (errcode == H_OK)
+    {
+        sess->rows = malloc(sizeof(SessionRowData) * result.nb_rows);
+        get_row_results(result, sess->fields, sess->rows, sizeof(SessionRowData));
+        h_clean_result(&result);
+    }
+    else
+    {
+        sloge("Error executing query %s returned %i", query, errcode);
+        free(query);
+        return -1;
+    }
+    free(query);
+
+    return result.nb_rows;
+}
+
+int getstints(struct _h_connection* conn, const char* sessionname, StintDbo* stint, int use_id)
+{
+    struct _h_result result;
+    struct _h_data* data;
+    char* query = malloc(150 * sizeof(char));
+    slogt("Performing query stints");
+
+
+    sprintf(query, "select stint_id, driver_id, team_member_id, session_id, car_id, game_car_id, laps, valid_laps, best_lap_id FROM %s WHERE session_id=%i", "Stints", use_id);
+    slogt("execute query %s", query);
+    int errcode = h_query_select(conn, query, &result);
+    if (errcode == H_OK)
+    {
+        stint->rows = malloc(sizeof(StintRowData) * result.nb_rows);
+        get_row_results(result, stint->fields, stint->rows, sizeof(StintRowData));
+        h_clean_result(&result);
+    }
+    else
+    {
+        sloge("Error executing query %s returned %i", query, errcode);
+        free(query);
+        return -1;
+    }
+    free(query);
+
+    return result.nb_rows;
+}
+
+int getlaps(struct _h_connection* conn, const char* sessionname, LapDbo* laps, int use_id)
+{
+    struct _h_result result;
+    struct _h_data* data;
+    char* query = malloc(250 * sizeof(char));
+    slogt("Performing query laps");
+
+    sprintf(query, "select lap_id, stint_id, sector_1, sector_2, sector_3, grip, tyre, time, cuts, crashes, max_speed, avg_speed, finished_at FROM %s WHERE %s=%i", "Laps", "stint_id", use_id);
+    int errcode = h_query_select(conn, query, &result);
+    if (errcode == H_OK)
+    {
+        laps->rows = malloc(sizeof(LapRowData) * result.nb_rows);
+        get_row_results(result, laps->fields, laps->rows, sizeof(LapRowData));
+        h_clean_result(&result);
+    }
+    else
+    {
+        sloge("Error executing query %s returned %i", query, errcode);
+        free(query);
+        return -1;
+    }
+    free(query);
+
+    return result.nb_rows;
+}
+
+int gettrack(struct _h_connection* conn, const char* trackname)
+{
+
+    json_t* j_result;
+    char* where_clause = h_build_where_clause(conn, "config_name=%s AND track_name=%s", "default", trackname);
+    json_t* j_query = json_pack("{sss[s]s{s{ssss}}}", "table", "track_config", "columns", "track_config_id", "where", " ", "operator", "raw",
+                                "value", where_clause);
+
+    char* qq;
+    int res = h_select(conn, j_query, &j_result, &qq);
+
+    // Deallocate j_query since it won't be needed anymore
+    //json_decref(j_query);
+    //h_free(where_clause);
+    int track_config = -1;
+    // Test query execution result
+    if (res == H_OK)
+    {
+        // Print result
+        //char* dump = json_dumps(j_result, JSON_INDENT(2));
+        //slogi("json select result is\n%s", dump);
+        int index1 = json_array_size(j_result);
+        //if (index1 == 0)
+        //{
+        //    slogw("no config for this track");
+        //}
+        //else {
+        json_t* jj = json_array_get(j_result, index1-1);
+        track_config = json_integer_value(json_object_get(jj, "track_config_id"));
+        //}
+        // Deallocate data result
+
+        //free(dump);
+    }
+    else
+    {
+        sloge("Error executing select query %s: %d", qq, res);
+    }
+    json_decref(j_result);
+    free(qq);
+    json_decref(j_query);
+    h_free(where_clause);
+    return track_config;
+}
+
+int getdriver(struct _h_connection* conn, const char* driver_name)
+{
+    json_t* j_result;
+    char* where_clause = h_build_where_clause(conn, "driver_name=%s", driver_name);
+    json_t* j_query = json_pack("{sss[s]s{s{ssss}}}","table", "drivers", "columns", "driver_id", "where", " ", "operator", "raw",
+                                "value", where_clause);
+
+    slogi("Looking for driver named %s", driver_name);
+    char* qq;
+    int res = h_select(conn, j_query, &j_result, &qq);
+    //slogi("here your query: %s", qq);
+    // Deallocate j_query since it won't be needed anymore
+    int driver_id = -1;
+    // Test query execution result
+    if (res == H_OK)
+    {
+        // Print result
+        char* dump = json_dumps(j_result, JSON_INDENT(2));
+        slogt("json select result is\n%s", dump);
+        int index1 = json_array_size(j_result);
+        if (index1 == 0)
+        {
+            slogw("no driver by this name");
+        }
+        else
+        {
+            json_t* jj = json_array_get(j_result, index1-1);
+            driver_id = json_integer_value(json_object_get(jj, "driver_id"));
+        }
+        // Deallocate data result
+        free(dump);
+    }
+    else
+    {
+        sloge("Error executing select query %s: %d", qq, res);
+    }
+    json_decref(j_result);
+    free(qq);
+    json_decref(j_query);
+    h_free(where_clause);
+    return driver_id;
+}
+
+int getcar(struct _h_connection* conn, const char* carname)
+{
+    json_t* j_result;
+    char* where_clause = h_build_where_clause(conn, "car_name=%s", carname);
+    json_t* j_query = json_pack("{sss[s]s{s{ssss}}}","table", "cars", "columns", "car_id", "where", " ", "operator", "raw",
+                                "value", where_clause);
+
+    slogi("Looking for car named %s", carname);
+    char* qq;
+    int res = h_select(conn, j_query, &j_result, &qq);
+    //slogi("here your query: %s", qq);
+    // Deallocate j_query since it won't be needed anymore
+
+    int car_id = -1;
+    // Test query execution result
+    if (res == H_OK)
+    {
+        // Print result
+        char* dump = json_dumps(j_result, JSON_INDENT(2));
+        slogt("json select result is\n%s", dump);
+        int index1 = json_array_size(j_result);
+        if (index1 == 0)
+        {
+            slogw("no car by this name");
+        }
+        else
+        {
+            json_t* jj = json_array_get(j_result, index1-1);
+            car_id = json_integer_value(json_object_get(jj, "car_id"));
+        }
+        // Deallocate data result
+        free(dump);
+    }
+    else
+    {
+        sloge("Error executing select query %s: %d", qq, res);
+    }
+    json_decref(j_result);
+    free(qq);
+    json_decref(j_query);
+    h_free(where_clause);
+    return car_id;
+}
+
+
+// inserts
+int addtrackconfig(struct _h_connection* conn, int trackconfigid, const char* track, int length)
+{
+    //track_config_id | track_name | config_name | display_name | country | city | length
+    if (trackconfigid > 0)
+    {
+        return trackconfigid;
+    }
+    json_t* root = json_object();
+    json_t* json_arr = json_array();
+
+    json_object_set_new( root, "table", json_string("track_config") );
+    json_object_set_new( root, "values", json_arr );
+
+    json_t* values = json_object();
+    json_object_set_new(values, "track_name", json_string(track));
+    json_object_set_new(values, "config_name", json_string("default"));
+    json_object_set_new(values, "display_name", json_string(track));
+    json_object_set_new(values, "country", json_string("USA"));
+    json_object_set_new(values, "city", json_string("USA"));
+    json_object_set_new(values, "length", json_integer(length));
+
+    json_array_append(json_arr, values);
+    char* qq;
+    int res = h_insert(conn, root, &qq);
+    json_decref(root);
+    json_decref(values);
+
+    if (res != 0)
+    {
+        sloge("track config insert result %i", res);
+        sloge("track config query %s", qq);
+        return -1;
+    }
+
+    trackconfigid = getLastInsertID(conn);
+    return trackconfigid;
+}
+
+int addsession(struct _h_connection* conn, int eventid, int carid, int eventtype, int airtemp, int tracktemp, SimData* simdata)
+{
+
+// session_id | event_id | event_type | track_time | session_name
+// | start_time | duration_min | elapsed_ms | laps | weather |
+// air_temp | road_temp | start_grip |
+    json_t* root = json_object();
+    json_t* json_arr = json_array();
+
+    json_object_set_new( root, "table", json_string("sessions") );
+    json_object_set_new( root, "values", json_arr );
+
+    json_t* values = json_object();
+    json_object_set_new(values, "event_id", json_integer(eventid));
+    json_object_set_new(values, "car_id", json_integer(carid));
+    json_object_set_new(values, "event_type", json_integer(1));
+    json_object_set_new(values, "duration_min", json_integer(60));
+    json_object_set_new(values, "start_time", json_string("NOW()"));
+    json_object_set_new(values, "session_name", json_string("default"));
+    json_object_set_new(values, "air_temp", json_integer(airtemp));
+    json_object_set_new(values, "road_temp", json_integer(tracktemp));
+    json_object_set_new(values, "weather", json_string("Windy"));
+    json_object_set_new(values, "http_port", json_integer(0));
+    json_array_append(json_arr, values);
+
+    char* qq;
+    int res = h_insert(conn, root, &qq);
+    json_decref(root);
+    json_decref(values);
+
+    if (res != 0)
+    {
+        sloge("track config insert result %i", res);
+        sloge("track config query %s", qq);
+        return -1;
+    }
+
+    return getLastInsertID(conn);
+}
+
+int adddriver(struct _h_connection* conn, int driverid, const char* drivername)
+{
+    if (driverid > 0)
+    {
+        return driverid;
+    }
+    json_t* root = json_object();
+    json_t* json_arr = json_array();
+
+    json_object_set_new( root, "table", json_string("drivers") );
+    json_object_set_new( root, "values", json_arr );
+
+    json_t* values = json_object();
+    json_object_set_new(values, "driver_name", json_string(drivername));
+    json_object_set_new(values, "prev_name", json_string(drivername));
+    json_object_set_new(values, "steam64_id", json_integer(17));
+    json_object_set_new(values, "country", json_string("USA"));
+    json_array_append(json_arr, values);
+
+    char* qq;
+    int res = h_insert(conn, root, &qq);
+    json_decref(root);
+    json_decref(values);
+
+    if (res != 0)
+    {
+        sloge("driver insert result %i", res);
+        sloge("driver insert query %s", qq);
+        return -1;
+    }
+
+
+    driverid = getLastInsertID(conn);
+    return driverid;
+}
+
+
+int addevent(struct _h_connection* conn, int track_config)
+{
+
+    json_t* root = json_object();
+    json_t* json_arr = json_array();
+
+    json_object_set_new( root, "table", json_string("events") );
+    json_object_set_new( root, "values", json_arr );
+
+    json_t* values = json_object();
+    json_object_set_new(values, "track_config_id", json_integer(track_config));
+    json_object_set_new(values, "event_name", json_string("default"));
+    //event_id | server_name | track_config_id | event_name | team_event | active | livery_preview | use_number | practice_duration | quali_duration | race_duration | race_duration_type | race_wait_time | race_extra_laps | reverse_grid_positions
+    json_array_append(json_arr, values);
+
+    char* qq;
+    int res = h_insert(conn, root, &qq);
+    json_decref(root);
+    json_decref(values);
+
+    if (res != 0)
+    {
+        sloge("event insert result %i", res);
+        sloge("event insert query %s", qq);
+        return -1;
+    }
+
+    return getLastInsertID(conn);
+}
+
+
+int addstint(struct _h_connection* conn, int sessionid, int driverid, int carid, SimData* simdata)
+{
+
+
+    json_t* root = json_object();
+    json_t* json_arr = json_array();
+
+    json_object_set_new( root, "table", json_string("stints") );
+    json_object_set_new( root, "values", json_arr );
+
+    json_t* values = json_object();
+
+    json_object_set_new(values, "driver_id", json_integer(driverid));
+    //team_member_id
+    json_object_set_new(values, "session_id", json_integer(sessionid));
+    json_object_set_new(values, "car_id", json_integer(carid));
+    json_object_set_new(values, "game_car_id", json_integer(carid));
+    json_object_set_new(values, "laps", json_integer(0));
+    json_object_set_new(values, "valid_laps", json_integer(0));
+    json_object_set_new(values, "tyre", json_string(simdata->tyrecompound) );
+    // best_lap_id
+    json_object_set_new(values, "is_finished", json_integer(0));
+
+    json_object_set_new(values, "started_at", json_string("NOW()") );
+    json_array_append(json_arr, values);
+
+    char* qq;
+    int res = h_insert(conn, root, &qq);
+    json_decref(root);
+    json_decref(values);
+
+    if (res != 0)
+    {
+        sloge("stint insert result %i", res);
+        sloge("stint insert query %s", qq);
+        return -1;
+    }
+
+    return getLastInsertID(conn);
+}
+
+int addstintlap(struct _h_connection* conn, int stintid, SimData* simdata)
+{
+
+    slogt("adding stint lap");
+// stint laps
+// stint_lap_id | stint_id | sector_1 | sector_2 | sector_3 | grip | tyre | time | cuts | crashes
+// max_speed | avg_speed | finished_at
+    json_t* root = json_object();
+    json_t* json_arr = json_array();
+
+    json_object_set_new( root, "table", json_string("laps") );
+    json_object_set_new( root, "values", json_arr );
+
+    json_t* values = json_object();
+
+    json_object_set_new(values, "stint_id", json_integer(stintid));
+    json_object_set_new(values, "tyre", json_string(simdata->tyrecompound) );
+    json_array_append(json_arr, values);
+
+    char* qq;
+    int res = h_insert(conn, root, &qq);
+    json_decref(root);
+    json_decref(values);
+
+    if (res != 0)
+    {
+        sloge("stint lap insert result %i", res);
+        sloge("stint lap insert query %s", qq);
+        return -1;
+    }
+
+    return getLastInsertID(conn);
+}
+
+int addcar(struct _h_connection* conn, int carid, const char* carname)
+{
+
+    // car_id | display_name | car_name | manufacturer | car_class
+
+    if (carid > 0)
+    {
+        return carid;
+    }
+    json_t* root = json_object();
+    json_t* json_arr = json_array();
+
+    json_object_set_new( root, "table", json_string("cars") );
+    json_object_set_new( root, "values", json_arr );
+
+    json_t* values = json_object();
+    json_object_set_new(values, "display_name", json_string(carname));
+    json_object_set_new(values, "car_name", json_string(carname));
+    json_object_set_new(values, "manufacturer", json_string("Unknown"));
+    json_object_set_new(values, "car_class", json_string("Unknown"));
+    json_array_append(json_arr, values);
+
+    char* qq;
+    int res = h_insert(conn, root, &qq);
+    json_decref(root);
+    json_decref(values);
+
+    if (res != 0)
+    {
+        sloge("car insert result %i", res);
+        sloge("car insert query %s", qq);
+        return -1;
+    }
+
+    return getLastInsertID(conn);
+}
+
+int addtelemetry(struct _h_connection* conn, int points, int stintid)
+{
+
+    slogt("adding telemetry record");
+
+    json_t* root = json_object();
+    json_t* json_arr = json_array();
+
+    json_object_set_new( root, "table", json_string("telemetry") );
+    json_object_set_new( root, "values", json_arr );
+
+    json_t* values = json_object();
+    json_object_set_new(values, "lap_id", json_integer(stintid));
+    json_object_set_new(values, "points", json_integer(points));
+    json_array_append(json_arr, values);
+
+    char* qq;
+    int res = h_insert(conn, root, &qq);
+    json_decref(root);
+    json_decref(values);
+
+    if (res != 0)
+    {
+        sloge("telemetry insert result %i", res);
+        sloge("telemetry insert query %s", qq);
+        return -1;
+    }
+
+    return getLastInsertID(conn);
+}
+
+
+int closelap(struct _h_connection* conn, int lapid, int sector1, int sector2, int sector3, int cuts, int crashes, int maxspeed, int avgspeed, SimData* simdata)
+{
+
+// stint laps
+// lap_id | stint_id | sector_1 | sector_2 | sector_3 | grip | tyre | time | cuts | crashes
+// max_speed | avg_speed | finished_at
+
+    slogt("closing previous lap ", lapid);
+
+    char* query = malloc((sizeof(char)*650));
+    sprintf(query, "UPDATE %s SET %s=%i, %s=%i, %s=%i, %s=%i, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, %s=%f, finished_at=NOW() WHERE lap_id=%i;",
+            "laps", "time", simdata->lastlap, "sector_1", sector1, "sector_2", sector2, "sector_3", sector3,
+            "right_front_tyre_temp", simdata->tyretemp[1],
+            "right_rear_tyre_temp",  simdata->tyretemp[3],
+            "right_front_tyre_wear", simdata->tyrewear[1],
+            "right_rear_tyre_wear",  simdata->tyrewear[3],
+            "right_front_tyre_press",simdata->tyrepressure[1],
+            "right_rear_tyre_press", simdata->tyrepressure[3],
+            "right_front_brake_temp",simdata->braketemp[1],
+            "right_rear_brake_temp", simdata->braketemp[3],
+            "left_front_tyre_temp", simdata->tyretemp[0],
+            "left_rear_tyre_temp",  simdata->tyretemp[2],
+            "left_front_tyre_wear", simdata->tyrewear[0],
+            "left_rear_tyre_wear",  simdata->tyrewear[2],
+            "left_front_tyre_press",simdata->tyrepressure[0],
+            "left_rear_tyre_press", simdata->tyrepressure[2],
+            "left_front_brake_temp",simdata->braketemp[0],
+            "left_rear_brake_temp", simdata->braketemp[2],
+            lapid);
+
+    int errcode = h_query_update(conn, query);
+    if (errcode != H_OK)
+    {
+        sloge("Error executing query %s returned %i", query, errcode);
+        free(query);
+        return -1;
+    }
+
+    slogt("closed previous lap");
+    free(query);
+    return errcode;
+}
+
+int closesession(struct _h_connection* conn, int sessionid)
+{
+
+    slogt("closing previous session ", sessionid);
+// best_lap_id
+
+// session_id | event_id | event_type | track_time | session_name
+// | start_time | duration_min | elapsed_ms | laps | weather |
+// air_temp | road_temp | start_grip | end_grip | is_finished
+
+    char* query = malloc((sizeof(char)*100));
+    sprintf(query, "UPDATE %s SET is_finished=1, finished_at=NOW() WHERE session_id=%i",
+            "sessions", sessionid);
+
+    int errcode = h_query_update(conn, query);
+    if (errcode != H_OK)
+    {
+        sloge("Error executing query %s returned %i", query, errcode);
+        free(query);
+        return -1;
+    }
+
+    slogt("closed previous session");
+    free(query);
+    return errcode;
+}
+
+
+int closestint(struct _h_connection* conn, int stintid, int stintlaps, int validstintlaps)
+{
+
+// best_lap_id
+    slogt("closing previous stint ", stintid);
+
+    char* query = malloc((sizeof(char)*146));
+    sprintf(query, "UPDATE %s SET %s = %i, %s = %i, is_finished=1, finished_at=NOW() WHERE stint_id=%i",
+            "stints", "laps", stintlaps, "valid_laps", validstintlaps, stintid);
+
+    int errcode = h_query_update(conn, query);
+    if (errcode != H_OK)
+    {
+        sloge("Error executing query %s returned %i", query, errcode);
+        free(query);
+        return -1;
+    }
+
+    slogt("closed previous stint");
+    free(query);
+    return errcode;
+}
@@ -0,0 +1,173 @@
+
+#ifndef _HOELDB_H
+#define _HOELDB_H
+
+#include <stddef.h>
+#include <stdbool.h>
+
+#include "../simulatorapi/simapi/simapi/simdata.h"
+
+typedef struct DBData DBData;
+typedef struct DBField DBField;
+typedef struct SessionFieldsData SessionFieldsData;
+typedef struct SessionFields SessionFields;
+typedef struct Session Session;
+typedef unsigned char PDBTimeStamp[27];
+
+struct DBField
+{
+    size_t offset;
+    size_t size;
+    int colnum;
+    int type;
+    char name[20];
+};
+
+//struct SessionFields
+//{
+//    DBField session_id;
+//    DBField laps;
+//};
+
+typedef struct SessionRowData
+{
+    int session_id;
+    int event_id;
+    int event_type;
+    //char track_time[5];
+    //char session_name[50];
+    //char start_time[6];
+    //int duration_min;
+    //int elapsed_ms;
+    int laps;
+    unsigned char track[150];
+    unsigned char car[150];
+    PDBTimeStamp start_time;
+    //char weather[100];
+    //double air_temp;
+    //double road_temp;
+    //double start_grip;
+    //double current_grip;
+    //int is_finished;
+    //char finish_time[6];
+    //char last_activity[6];
+    //int http_port;
+
+}
+SessionRowData;
+
+//struct SessionFieldsData
+//{
+//    int session_id;
+//    int laps;
+//};
+
+typedef struct StintRowData
+{
+    int stint_id;
+    int driver_id;
+    int team_member_id;
+    int session_id;
+    int car_id;
+    int game_car_id;
+    int laps;
+    int valid_laps;
+    int best_lap_id;
+    unsigned char tyre[10];
+}
+StintRowData;
+
+typedef struct LapRowData
+{
+    int lap_id;
+    int stint_id;
+    int sector_1;
+    int sector_2;
+    int sector_3;
+    double grip;
+    unsigned char tyre[10];
+    int time;
+    int cuts;
+    int crashes;
+    int max_speed;
+    int avg_speed;
+    PDBTimeStamp finished_at;
+    //double f_tyre_temp;
+    //double r_tyre_temp;
+    //double f_tyre_wear;
+    //double r_tyre_wear;
+    //double f_tyre_press;
+    //double r_tyre_press;
+    //double f_brake_temp;
+    //double r_brake_temp;
+}
+LapRowData;
+
+typedef struct SessionDbo
+{
+    int numrows;
+    bool hasdata;
+
+    DBField fields[7];
+    SessionRowData* rows;
+}
+SessionDbo;
+
+typedef struct StintDbo
+{
+    int numrows;
+    bool hasdata;
+
+    DBField fields[9];
+    StintRowData* rows;
+}
+StintDbo;
+
+typedef struct LapDbo
+{
+    int numrows;
+    bool hasdata;
+
+    DBField fields[13];
+    LapRowData* rows;
+}
+LapDbo;
+
+int getLastInsertID(struct _h_connection* conn);
+
+void get_row_results(struct _h_result result, DBField* fields, void* rows, size_t rowsize);
+
+int getsessions(struct _h_connection* conn, const char* sessionname, SessionDbo* sess);
+
+int getstints(struct _h_connection* conn, const char* sessionname, StintDbo* stint, int use_id);
+
+int getlaps(struct _h_connection* conn, const char* sessionname, LapDbo* laps, int use_id);
+
+int gettrack(struct _h_connection* conn, const char* trackname);
+
+int getdriver(struct _h_connection* conn, const char* driver_name);
+
+int getcar(struct _h_connection* conn, const char* carname);
+
+int addtrackconfig(struct _h_connection* conn, int trackconfigid, const char* track, int length);
+
+int adddriver(struct _h_connection* conn, int driverid, const char* drivername);
+
+int addevent(struct _h_connection* conn, int track_config);
+
+int addsession(struct _h_connection* conn, int eventid, int carid, int eventtype, int airtemp, int tracktemp, SimData* simdata);
+
+int addstint(struct _h_connection* conn, int sessionid, int driverid, int carid, SimData* simdata);
+
+int addstintlap(struct _h_connection* conn, int stintid, SimData* simdata);
+
+int addcar(struct _h_connection* conn, int carid, const char* carname);
+
+int addtelemetry(struct _h_connection* conn, int points, int stintid);
+
+int closelap(struct _h_connection* conn, int lapid, int sector1, int sector2, int sector3, int cuts, int crashes, int maxspeed, int avgspeed, SimData* simdata);
+
+int closestint(struct _h_connection* conn, int stintid, int stintlaps, int validstintlaps);
+
+int closesession(struct _h_connection* conn, int sessionid);
+#endif
@@ -1,130 +0,0 @@
-
-#ifndef _SESSION_H
-#define _SESSION_H
-
-#include <stddef.h>
-#include <stdbool.h>
-
-typedef struct DBData DBData;
-typedef struct DBField DBField;
-typedef struct SessionFieldsData SessionFieldsData;
-typedef struct SessionFields SessionFields;
-typedef struct Session Session;
-typedef unsigned char PDBTimeStamp[26];
-
-struct DBField
-{
-    size_t offset;
-    size_t size;
-    int colnum;
-    int type;
-    char name[20];
-};
-
-//struct SessionFields
-//{
-//    DBField session_id;
-//    DBField laps;
-//};
-
-typedef struct SessionRowData
-{
-    int session_id;
-    int event_id;
-    int event_type;
-    //char track_time[5];
-    //char session_name[50];
-    //char start_time[6];
-    //int duration_min;
-    //int elapsed_ms;
-    int laps;
-    //char weather[100];
-    //double air_temp;
-    //double road_temp;
-    //double start_grip;
-    //double current_grip;
-    //int is_finished;
-    //char finish_time[6];
-    //char last_activity[6];
-    //int http_port;
-
-}
-SessionRowData;
-
-//struct SessionFieldsData
-//{
-//    int session_id;
-//    int laps;
-//};
-
-typedef struct StintRowData
-{
-    int stint_id;
-    int driver_id;
-    int team_member_id;
-    int session_id;
-    int car_id;
-    int game_car_id;
-    int laps;
-    int valid_laps;
-    int best_lap_id;
-}
-StintRowData;
-
-typedef struct LapRowData
-{
-    int lap_id;
-    int stint_id;
-    int sector_1;
-    int sector_2;
-    int sector_3;
-    double grip;
-    unsigned char tyre[10];
-    int time;
-    int cuts;
-    int crashes;
-    int max_speed;
-    int avg_speed;
-    double f_tyre_temp;
-    double r_tyre_temp;
-    double f_tyre_wear;
-    double r_tyre_wear;
-    double f_tyre_press;
-    double r_tyre_press;
-    double f_brake_temp;
-    double r_brake_temp;
-    PDBTimeStamp finished_at;
-}
-LapRowData;
-
-typedef struct SessionDbo
-{
-    int numrows;
-    bool hasdata;
-
-    DBField fields[4];
-    SessionRowData* rows;
-}
-SessionDbo;
-
-typedef struct StintDbo
-{
-    int numrows;
-    bool hasdata;
-
-    DBField fields[9];
-    StintRowData* rows;
-}
-StintDbo;
-
-typedef struct LapDbo
-{
-    int numrows;
-    bool hasdata;
-
-    DBField fields[21];
-    LapRowData* rows;
-}
-LapDbo;
-
-#endif
@@ -0,0 +1,297 @@
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <hoel.h>
+#include <jansson.h>
+
+#include "telemetry.h"
+#include "../helper/confighelper.h"
+#include "../slog/slog.h"
+
+int telem_result(struct _h_result result, int doublefields, int intfields, int* intarrays, double* doublearrays)
+{
+    int col, row, i;
+    char buf[64];
+    slogt("rows: %d, col: %d", result.nb_rows, result.nb_columns);
+    //int* intarrays;
+    int points = 0;
+    //int doublefields = 3;
+    //int intfields = 3;
+    //int* intarrays;
+    //int* doublearrays;
+    //int* intarrays = malloc((sizeof(int)*1736)*3);
+    //double* doublearrays = malloc((sizeof(double)*1736)*3);
+    int intarrayoffset = 0;
+    int doublearrayoffset = 0;
+
+    for (row = 0; row<result.nb_rows; row++)
+    {
+        for (col=0; col<result.nb_columns; col++)
+        {
+            switch(result.data[row][col].type)
+            {
+                case HOEL_COL_TYPE_INT:
+                    int cc = ((struct _h_type_int*)result.data[row][col].t_data)->value;
+                    if (col == 1)
+                    {
+                        points = cc;
+                    }
+                    break;
+                case HOEL_COL_TYPE_DOUBLE:
+                    //intarrays = malloc((sizeof(int)*1736)*3);
+                    break;
+                case HOEL_COL_TYPE_TEXT:
+                    slogi("| %s ", ((struct _h_type_text*)result.data[row][col].t_data)->value);
+                    break;
+                case HOEL_COL_TYPE_BLOB:
+                    int offset2 = 0;
+
+                    int j = 0;
+                    i = 2;
+                    if (col < 5)
+                    {
+                        while (i<((struct _h_type_blob*)result.data[row][col].t_data)->length)
+                        {
+                            char sss[10];
+                            sss[0] = '0';
+                            sss[1] = 'x';
+                            sss[2] = *((char*)((struct _h_type_blob*)result.data[row][col].t_data)->value+offset2+2);
+                            sss[3] = *((char*)((struct _h_type_blob*)result.data[row][col].t_data)->value+offset2+3);
+                            sss[4] = *((char*)((struct _h_type_blob*)result.data[row][col].t_data)->value+offset2+4);
+                            sss[5] = *((char*)((struct _h_type_blob*)result.data[row][col].t_data)->value+offset2+5);
+                            sss[6] = *((char*)((struct _h_type_blob*)result.data[row][col].t_data)->value+offset2+6);
+                            sss[7] = *((char*)((struct _h_type_blob*)result.data[row][col].t_data)->value+offset2+7);
+                            sss[8] = *((char*)((struct _h_type_blob*)result.data[row][col].t_data)->value+offset2+8);
+                            sss[9] = *((char*)((struct _h_type_blob*)result.data[row][col].t_data)->value+offset2+9);
+                            long val;
+                            int number = (int)strtol(sss, NULL, 16);
+                            int swapped = __bswap_32(number);
+
+                            intarrays[j+intarrayoffset] = __bswap_32(number);
+                            offset2 = offset2 + 8;
+                            i+=8;
+                            j++;
+                        }
+                        intarrayoffset += points;
+                    }
+                    else
+                    {
+                        while (i<((struct _h_type_blob*)result.data[row][col].t_data)->length)
+                        {
+                            char sss[18];
+                            sss[0] = '0';
+                            sss[1] = 'x';
+                            sss[2] = *((char*)((struct _h_type_blob*)result.data[row][col].t_data)->value+offset2+2);
+                            sss[3] = *((char*)((struct _h_type_blob*)result.data[row][col].t_data)->value+offset2+3);
+                            sss[4] = *((char*)((struct _h_type_blob*)result.data[row][col].t_data)->value+offset2+4);
+                            sss[5] = *((char*)((struct _h_type_blob*)result.data[row][col].t_data)->value+offset2+5);
+                            sss[6] = *((char*)((struct _h_type_blob*)result.data[row][col].t_data)->value+offset2+6);
+                            sss[7] = *((char*)((struct _h_type_blob*)result.data[row][col].t_data)->value+offset2+7);
+                            sss[8] = *((char*)((struct _h_type_blob*)result.data[row][col].t_data)->value+offset2+8);
+                            sss[9] = *((char*)((struct _h_type_blob*)result.data[row][col].t_data)->value+offset2+9);
+                            sss[2+8] = *((char*)((struct _h_type_blob*)result.data[row][col].t_data)->value+offset2+2+8);
+                            sss[3+8] = *((char*)((struct _h_type_blob*)result.data[row][col].t_data)->value+offset2+3+8);
+                            sss[4+8] = *((char*)((struct _h_type_blob*)result.data[row][col].t_data)->value+offset2+4+8);
+                            sss[5+8] = *((char*)((struct _h_type_blob*)result.data[row][col].t_data)->value+offset2+5+8);
+                            sss[6+8] = *((char*)((struct _h_type_blob*)result.data[row][col].t_data)->value+offset2+6+8);
+                            sss[7+8] = *((char*)((struct _h_type_blob*)result.data[row][col].t_data)->value+offset2+7+8);
+                            sss[8+8] = *((char*)((struct _h_type_blob*)result.data[row][col].t_data)->value+offset2+8+8);
+                            sss[9+8] = *((char*)((struct _h_type_blob*)result.data[row][col].t_data)->value+offset2+9+8);
+                            long val;
+                            int64_t number = (int64_t) strtoll(sss, NULL, 16);
+                            int64_t swapped = __bswap_64(number);
+                            double d = *((double*)&swapped);
+                            doublearrays[j+doublearrayoffset] = (double) d;
+                            offset2 = offset2 + 16;
+                            i+=16;
+                            j++;
+                        }
+                        doublearrayoffset += points;
+
+                    }
+                    //snprintf( "blob value: %.*s", ((struct _h_type_blob *)result.data[row][col].t_data)->length, ((struct _h_type_blob *)result.data[row][col].t_data)->value);
+                    //char* b = malloc(sizeof(int)*1736);
+                    //for (i=0; i<((struct _h_type_blob *)result.data[row][col].t_data)->length; i++) {
+                    //  //slogi("%c", *((char*)(((struct _h_type_blob *)result.data[row][col].t_data)->value+i)));
+                    //  memcpy(&b[i], ((struct _h_type_blob *)result.data[row][col].t_data)->value+1*sizeof(char), sizeof(char));
+                    //}
+//          FILE *out = fopen("memory.bin", "wb");
+//  if(out != NULL)
+//  {
+//    size_t to_go = sizeof(int)*1736;
+//    while(to_go > 0)
+//    {
+//      const size_t wrote = fwrite(b, to_go, 1, out);
+//      if(wrote == 0)
+//        break;
+//      to_go -= wrote;
+//    }
+//    fclose(out);
+//  }
+                    break;
+                case HOEL_COL_TYPE_DATE:
+                    strftime(buf, 64, "%Y-%m-%d %H:%M:%S", &((struct _h_type_datetime*)result.data[row][col].t_data)->value);
+                    printf("| %s ", buf);
+                case HOEL_COL_TYPE_NULL:
+                    slogi("| [null] ");
+                    break;
+            }
+        }
+        printf("|\n");
+    }
+
+    return points;
+}
+
+int dumptelemetrytofile(struct _h_connection* conn, char* datadir, int lap1id, int lap2id)
+{
+
+    slogt("dumping telemetry to temp file: lap1id: %d lap2id: %d", lap1id, lap2id);
+
+    int points = 0;
+    int intfields = 3;
+    int doublefields = 3;
+
+    struct _h_result result;
+    struct _h_data* data;
+    char* query = malloc(150 * sizeof(char));
+    sprintf(query, "SELECT lap_id, points FROM %s WHERE %s=%i", "telemetry", "lap_id", lap1id);
+    if (h_query_select(conn, query, &result) == H_OK)
+    {
+        //laps->rows = malloc(sizeof(LapRowData) * result.nb_rows);
+        //get_row_results(result, laps->fields, laps->rows, sizeof(LapRowData));
+        points = telem_result(result, 3, 3, NULL, NULL);
+        //get_stint_result(result, stint);
+        h_clean_result(&result);
+    }
+    else
+    {
+        printf("Error executing query\n");
+    }
+    free(query);
+
+
+    int* intarrays1 = malloc((sizeof(int))*points*intfields);
+    double* doublearrays1 = malloc((sizeof(double))*points*doublefields);
+    int* intarrays2 = malloc((sizeof(int))*points*intfields);
+    double* doublearrays2 = malloc((sizeof(double))*points*doublefields);
+
+    struct _h_result result1;
+    struct _h_data* data1;
+    char* query1 = malloc(150 * sizeof(char));
+    sprintf(query1, "SELECT lap_id, points, speed, gear, rpms, brake, accel, steer FROM %s WHERE %s=%i", "telemetry", "lap_id", lap1id);
+    if (h_query_select(conn, query1, &result1) == H_OK)
+    {
+        //laps->rows = malloc(sizeof(LapRowData) * result.nb_rows);
+        //get_row_results(result, laps->fields, laps->rows, sizeof(LapRowData));
+        points = telem_result(result1, intfields, doublefields, intarrays1, doublearrays1);
+        //get_stint_result(result, stint);
+        h_clean_result(&result1);
+    }
+    else
+    {
+        printf("Error executing query\n");
+    }
+    free(query1);
+
+    struct _h_result result2;
+    struct _h_data* data2;
+    char* query2 = malloc(150 * sizeof(char));
+    sprintf(query2, "SELECT lap_id, points, speed, gear, rpms, brake, accel, steer FROM %s WHERE %s=%i", "telemetry", "lap_id", lap2id);
+    if (h_query_select(conn, query2, &result2) == H_OK)
+    {
+        //laps->rows = malloc(sizeof(LapRowData) * result.nb_rows);
+        //get_row_results(result, laps->fields, laps->rows, sizeof(LapRowData));
+        points = telem_result(result2, intfields, doublefields, intarrays2, doublearrays2);
+        //get_stint_result(result, stint);
+        h_clean_result(&result2);
+    }
+    else
+    {
+        printf("Error executing query\n");
+    }
+    free(query2);
+
+    char* filename1 = "data.out";
+    size_t strsize = strlen(datadir) + strlen(filename1) + 1;
+    char* datafile = malloc(strsize);
+
+    snprintf(datafile, strsize, "%s%s", datadir, filename1);
+    slogt("dumping %i points to file %s", points, datafile);
+    FILE* out = fopen(datafile, "w");
+    fprintf(out, "%s %s %s %s %s %s %s %s %s %s %s %s %s\n", "point", "speed1", "rpms1", "gear1", "brake1", "accel1", "steer1", "speed2", "rpms2", "gear2", "brake2", "accel2", "steer2" );
+    for (int i=0; i<points; i++)
+    {
+        fprintf(out, "%i %i %i %i %f %f %f", i+1, intarrays1[i], intarrays1[i+points], intarrays1[i+(points*2)], doublearrays1[i], doublearrays1[i+points], doublearrays1[i+(points*2)]);
+        fprintf(out, "%i %i %i %i %f %f %f\n", i+1, intarrays2[i], intarrays2[i+points], intarrays2[i+(points*2)], doublearrays2[i], doublearrays2[i+points], doublearrays2[i+(points*2)]);
+    }
+    fclose(out);
+
+    free(intarrays1);
+    free(intarrays2);
+    free(doublearrays1);
+    free(doublearrays2);
+    free(datafile);
+
+    return 1;
+}
+
+void print_bytes(void* ptr, int size)
+{
+    char* pp = malloc((size*2)+1);
+    char output[(size * 2) + 1];
+    char* ppp = &output[0];
+    unsigned char* p = ptr;
+    int i;
+    for (i=0; i<size; i++)
+    {
+        slogt("%02hhX", p[i]);
+        ppp += sprintf(ppp, "%02X", p[i]);
+        //snprintf(pp, (size*2)+1, "%s%02hhX", pp, p[i]);
+    }
+    slogt("\n");
+    slogt("bytes %s", output);
+}
+
+int updatetelemetry(struct _h_connection* conn, int telemid, int size, const char* column, void* data)
+{
+
+    //char *pp = malloc((size*2)+1);
+    char output[(size * 2) + 1];
+    char* ppp = &output[0];
+    unsigned char* p = data;
+    int i;
+    for (i=0; i<size; i++)
+    {
+        ppp += sprintf(ppp, "%02hhX", p[i]);
+        //snprintf(pp, (size*2)+1, "%s%02hhX", pp, p[i]);
+    }
+
+    char* query = malloc((sizeof(char)*71)+(sizeof(column))+(size*2)+1);
+    sprintf(query, "UPDATE telemetry SET %s = decode('%s', 'hex') WHERE telemetry_id = %i", column, &output, telemid);
+    int res1 = h_query_update(conn, query);
+    //int res1 = h_insert(conn, j_query, NULL);
+    slogt("got res %i", res1);
+    free(query);
+
+    return res1;
+}
+
+int updatetelemetrydata(struct _h_connection* conn, int tracksamples, int telemid, int lapid,
+                        int* speeddata, int* rpmdata, int* geardata,
+                        double* steerdata, double* acceldata, double* brakedata)
+{
+    int b = 0;
+    b = updatetelemetry(conn, telemid, tracksamples*sizeof(double), "steer", steerdata);
+    b = updatetelemetry(conn, telemid, tracksamples*sizeof(double), "accel", acceldata);
+    b = updatetelemetry(conn, telemid, tracksamples*sizeof(double), "brake", brakedata);
+    b = updatetelemetry(conn, telemid, tracksamples*sizeof(int), "rpms", rpmdata);
+    b = updatetelemetry(conn, telemid, tracksamples*sizeof(int), "gear", geardata);
+    b = updatetelemetry(conn, telemid, tracksamples*sizeof(int), "speed", speeddata);
+
+    return b;
+}
@@ -0,0 +1,12 @@
+#ifndef _TELEMETRY_H
+#define _TELEMETRY_H
+
+int dumptelemetrytofile(struct _h_connection* conn, char* datadir, int lap1id, int lap2id);
+
+void print_bytes(void* ptr, int size);
+
+int updatetelemetrydata(struct _h_connection* conn, int tracksamples, int telemid, int lapid,
+                        int* speeddata, int* rpmdata, int* geardata,
+                        double* steerdata, double* acceldata, double* brakedata);
+
+#endif
@@ -9,45 +9,13 @@
 #include <basedir_fs.h>

 #include "gameloop/gameloop.h"
+#include "gameloop/browseloop.h"
 #include "helper/parameters.h"
 #include "helper/dirhelper.h"
 #include "helper/confighelper.h"
 #include "slog/slog.h"

-int create_dir(char* dir)
-{
-    struct stat st = {0};
-    if (stat(dir, &st) == -1)
-    {
-        mkdir(dir, 0700);
-    }
-}
-
-char* create_user_dir(const char* dirtype)
-{
-    char* config_dir_str = ( char* ) malloc(1 + strlen(dirtype) + strlen("/gilles"));
-    strcpy(config_dir_str, dirtype);
-    strcat(config_dir_str, "/gilles");
-
-    create_dir(config_dir_str);
-    free(config_dir_str);
-}
-
-char* get_config_file(const char* confpath, xdgHandle* xdg)
-{
-    if(strcmp(confpath, "") != 0)
-    {
-        fprintf(stderr, "no config path specified");
-        return strdup(confpath);
-    }
-
-    const char* relpath = "gilles/gilles.config";
-    const char* confpath1 = xdgConfigFind(relpath, xdg);
-    slogi("path is %s", confpath1);
-    return strdup(confpath1);
-}
-
-
+#define PROGRAM_NAME "gilles"

 int main(int argc, char** argv)
 {
@@ -63,18 +31,15 @@ int main(int argc, char** argv)
    p->program_state = 1;

    char* home_dir_str = gethome();
-    create_user_dir("/.config/");
-    create_user_dir("/.cache/");
-    char* cache_dir_str = ( char* ) malloc(1 + strlen(home_dir_str) + strlen("/.cache/gilles/"));
-    strcpy(cache_dir_str, home_dir_str);
-    strcat(cache_dir_str, "/.cache/gilles/");
+
+    char* cachedir = create_user_dir(home_dir_str, ".cache", PROGRAM_NAME);

    slog_config_t slgCfg;
    slog_config_get(&slgCfg);
    slgCfg.eColorFormat = SLOG_COLORING_TAG;
    slgCfg.eDateControl = SLOG_TIME_ONLY;
    strcpy(slgCfg.sFileName, "gilles.log");
-    strcpy(slgCfg.sFilePath, cache_dir_str);
+    strcpy(slgCfg.sFilePath, cachedir);
    slgCfg.nTraceTid = 0;
    slgCfg.nToScreen = 1;
    slgCfg.nUseHeap = 0;
@@ -91,25 +56,36 @@ int main(int argc, char** argv)
        slog_disable(SLOG_DEBUG);
    }

+    char* configdir = create_user_dir(home_dir_str, ".config", PROGRAM_NAME);
+    char* datadir = create_user_dir(home_dir_str, ".local/share", PROGRAM_NAME);
+
    xdgHandle xdg;
    if(!xdgInitHandle(&xdg))
    {
        slogf("Function xdgInitHandle() failed, is $HOME unset?");
    }
-    char* config_file_str = get_config_file("/home/paul/.config/gilles/gilles.config", &xdg);

-    loadconfig(config_file_str, p);
-    //slogi("mysql user is %s", p->mysql_user);
+    char* config_file_str = get_config_file(p->config_path, &xdg);
+    int err = loadconfig(config_file_str, p);

    free(config_file_str);
-    free(cache_dir_str);
    xdgWipeHandle(&xdg);

-    mainloop(p);
-    //free(config_file_str);
-    //free(cache_dir_str);
-    //free(simmap);
-    //free(simdata);
+    if (err == E_NO_ERROR)
+    {
+        if (p->program_action == A_PLAY)
+        {
+            mainloop(p);
+        }
+        else
+        {
+            browseloop(p, datadir);
+        }
+        if (p->err != E_NO_ERROR)
+        {
+            sloge("Error occured during execution.");
+        }
+    }


 configcleanup:
@@ -119,7 +95,11 @@ cleanup_final:
    freeparams(p);
    free(gs);
    free(p);
+
+    free(configdir);
+    free(datadir);
+    free(cachedir);
+
    exit(0);
 }

-
@@ -3,10 +3,12 @@
 #include <string.h>
 #include <stdint.h>
 #include <stdlib.h>
+#include <unistd.h>

 #include "confighelper.h"

 #include "../slog/slog.h"
+#include "parameters.h"

 //int strtogame(const char* game, GillesSettings* gs)
 //{
@@ -30,21 +32,34 @@
 //    return GILLES_ERROR_NONE;
 //}

-int loadmysql(config_t* cfg, Parameters* p)
+int loaddbconfig(config_t* cfg, Parameters* p)
 {
-    config_setting_t* config_mysql_array = NULL;
-    config_mysql_array = config_lookup(cfg, "mysql");
+    config_setting_t* config_db_array = NULL;
+    config_db_array = config_lookup(cfg, "db");

-    config_setting_t* config_mysql = NULL;
-    config_mysql = config_setting_get_elem(config_mysql_array, 0);
+    config_setting_t* config_db = NULL;
+    config_db = config_setting_get_elem(config_db_array, 0);

-    if (config_mysql == NULL) {
-        slogi("found no mysql settings");
+    if (config_db == NULL) {
+        slogi("found no db settings");
+        return E_BAD_CONFIG;
    }
    const char* temp;
-    config_setting_lookup_string(config_mysql, "user", &temp);
-    p->mysql_user = strdup(temp);
-    return 0;
+    config_setting_lookup_string(config_db, "user", &temp);
+    p->db_user = strdup(temp);
+    config_setting_lookup_string(config_db, "password", &temp);
+    p->db_pass = strdup(temp);
+    config_setting_lookup_string(config_db, "server", &temp);
+    p->db_serv = strdup(temp);
+    config_setting_lookup_string(config_db, "database", &temp);
+    p->db_dbnm = strdup(temp);
+
+    size_t strsize = strlen(p->db_user) + strlen(p->db_pass) + strlen(p->db_serv) + strlen(p->db_dbnm) + 29 + 1;
+    p->db_conn = malloc(strsize);
+
+    snprintf(p->db_conn, strsize, "host=%s dbname=%s user=%s password=%s", p->db_serv, p->db_dbnm, p->db_user, p->db_pass);
+
+    return E_NO_ERROR;
 }

 int loadconfig(const char* config_file_str, Parameters* p)
@@ -58,9 +73,49 @@ int loadconfig(const char* config_file_str, Parameters* p)
    else
    {
        slogi("Parsing config file");
-        if (p->mysql == true)
+
+
+        if (p->program_action == A_BROWSE)
        {
-            loadmysql(&cfg, p);
+            char* gnuplotbin = "/usr/bin/gnuplot";
+            config_setting_t* config_graph_array = NULL;
+            config_graph_array = config_lookup(&cfg, "graph");
+
+            config_setting_t* config_graph = NULL;
+            config_graph = config_setting_get_elem(config_graph_array, 0);
+
+            if (config_graph == NULL) {
+                slogi("found no graph settings");
+                return E_BAD_CONFIG;
+            }
+            const char* temp;
+            config_setting_lookup_string(config_graph, "gnuplotfile", &temp);
+            p->gnuplot_file = strdup(temp);
+            slogt("set gnuplot config file %s", p->gnuplot_file);
+
+            int found = config_setting_lookup_string(config_graph, "gnuplotbin", &temp);
+            if (found > 0)
+            {
+                p->gnuplot_bin = strdup(temp);
+            }
+            else
+            {
+                p->gnuplot_bin = strdup(gnuplotbin);
+            }
+            p->gnuplotfound = 0;
+            if (access(p->gnuplot_bin, F_OK) == 0)
+            {
+                p->gnuplotfound = 1;
+            }
+        }
+
+        if (p->mysql == true || p->program_action == A_BROWSE)
+        {
+            int err = loaddbconfig(&cfg, p);
+            if (err != E_NO_ERROR)
+            {
+                return err;
+            }
        }
    }

@@ -18,15 +18,6 @@ typedef enum
 }
 SimulatorUpdate;

-typedef enum
-{
-    GILLES_ERROR_NONE          = 0,
-    GILLES_ERROR_UNKNOWN       = 1,
-    GILLES_ERROR_INVALID_SIM   = 2,
-    GILLES_ERROR_NODATA        = 4,
-}
-GillesError;
-
 typedef struct
 {
    ProgramAction program_action;
@@ -3,22 +3,72 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdbool.h>
+#include <dirent.h>
+
 #include <pwd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
 #include <time.h>

+
 #include <string.h>


-#include <sys/stat.h>
-#include <sys/types.h>
-#if defined(OS_WIN)
-    #include <windows.h>
-#else
-    #include <dirent.h> // for *Nix directory access
-    #include <unistd.h>
-#endif
+
+#include "../slog/slog.h"


+#define CONFIG_FILE "gilles/gilles.config"
+
+void create_dir(char* dir)
+{
+    struct stat st = {0};
+    if (stat(dir, &st) == -1)
+    {
+        mkdir(dir, 0700);
+    }
+}
+
+char* create_user_dir(char* home_dir_str, const char* dirtype, const char* programname)
+{
+    // +3 for slashes
+    size_t ss = (4 + strlen(home_dir_str) + strlen(dirtype) + strlen(programname));
+    char* config_dir_str = malloc(ss);
+
+    snprintf (config_dir_str, ss, "%s/%s/%s/", home_dir_str, dirtype, programname);
+
+    slogt("creating dir for %s if necessary", config_dir_str);
+    create_dir(config_dir_str);
+    return config_dir_str;
+}
+
+
+char* get_config_file(const char* confpath, xdgHandle* xdg)
+{
+    if ((confpath != NULL) && (strcmp(confpath, "") != 0))
+    {
+        slogw("Using custom config path %s", confpath);
+        return strdup(confpath);
+    }
+
+    const char* relpath = CONFIG_FILE;
+    char* confpath1 = xdgConfigFind(relpath, xdg);
+    slogi("config path is %s", confpath1);
+    return confpath1;
+}
+
+
+char* get_dir_with_default(const char* dirpath, char* defaultpath)
+{
+    if ((dirpath != NULL) && (strcmp(dirpath, "") != 0))
+    {
+        slogw("Using custom config path %s", dirpath);
+        return strdup(dirpath);
+    }
+
+    return defaultpath;
+}

 char* gethome()
 {
@@ -207,47 +257,3 @@ bool does_directory_exist(char* path, char* dirname)
    return answer;
 }

-
-
-bool file_exists(const char* file)
-{
-    if (file == NULL) { return false; }
-    #if defined(OS_WIN)
-        #if defined(WIN_API)
-            // if you want the WinAPI, versus CRT
-            if (strnlen(file, MAX_PATH+1) > MAX_PATH) {
-                // ... throw error here or ...
-                return false;
-            }
-            DWORD res = GetFileAttributesA(file);
-            return (res != INVALID_FILE_ATTRIBUTES &&
-                !(res & FILE_ATTRIBUTE_DIRECTORY));
-        #else
-            // Use Win CRT
-            struct stat fi;
-            if (_stat(file, &fi) == 0) {
-                #if defined(S_ISSOCK)
-                    // sockets come back as a 'file' on some systems
-                    // so make sure it's not a socket or directory
-                    // (in other words, make sure it's an actual file)
-                    return !(S_ISDIR(fi.st_mode)) &&
-                        !(S_ISSOCK(fi.st_mode));
-                #else
-                    return !(S_ISDIR(fi.st_mode));
-                #endif
-            }
-            return false;
-        #endif
-    #else
-        struct stat fi;
-        if (stat(file, &fi) == 0) {
-            #if defined(S_ISSOCK)
-                return !(S_ISDIR(fi.st_mode)) &&
-                    !(S_ISSOCK(fi.st_mode));
-            #else
-                return !(S_ISDIR(fi.st_mode));
-            #endif
-        }
-        return false;
-    #endif
-}
@@ -3,11 +3,16 @@

 #include <stdbool.h>

+#include <basedir_fs.h>
+
+void create_dir(char* dir);
+char* create_user_dir(char* home_dir_str, const char* dirtype, const char* programpath);
 char* gethome();
 char* str2md5(const char* str, int length);
 bool does_directory_exist(char* path, char* dirname);
 void restrict_folders_to_cache(char* path, int cachesize);
 void delete_dir(char* path);
-bool file_exists(const char* file);
+char* get_config_file(const char* confpath, xdgHandle* xdg);
+char* get_dir_with_default(const char* dirpath, char* defaultpath);

 #endif
@@ -14,12 +14,24 @@ int freeparams(Parameters* p)
    {
        free(p->sim_string);
    }
-    if (p->mysql == true)
+    if (p->mysql == true || p->program_action == A_BROWSE)
    {
-        if(p->mysql_user != NULL)
+        if(p->db_user != NULL)
        {
-            free(p->mysql_user);
+            free(p->db_user);
        }
+        if(p->db_conn != NULL)
+        {
+            free(p->db_conn);
+        }
+    }
+    if (p->program_action == A_BROWSE)
+    {
+        free(p->gnuplot_bin);
+    }
+    if (p->config_path != NULL)
+    {
+        free(p->config_path);
    }
    return 0;
 }
@@ -45,6 +57,7 @@ ConfigError getParameters(int argc, char** argv, Parameters* p)

    struct arg_rex* cmd1             = arg_rex1(NULL, NULL, "play", NULL, REG_ICASE, NULL);
    struct arg_rex* cmd2             = arg_rex1(NULL, NULL, "browse", NULL, REG_ICASE, NULL);
+    struct arg_str* arg_cpath        = arg_strn("f", "configpath", "<path of config>", 0, 1, NULL);
    struct arg_str* arg_sim          = arg_strn("s", "sim", "<gamename>", 0, 1, NULL);
    struct arg_lit* arg_cli          = arg_lit0("c",  "textui", "text only ui");
    struct arg_lit* arg_mqtt         = arg_lit0("Q",  "mqtt", "send data to local mqtt server with connection settings speciifed in config");
@@ -93,17 +106,22 @@ ConfigError getParameters(int argc, char** argv, Parameters* p)
        {
            p->mysql = true;
        }
+        if (arg_cpath->sval[0] != NULL)
+        {
+            p->config_path = strdup(arg_cpath->sval[0]);
+        }
        exitcode = E_SUCCESS_AND_DO;
    }
-
-    if (nerrors1==0)
+    else
    {
-        p->program_action = A_BROWSE;
-        //p->sim_string = strdup(arg_sim->sval[0]);
-        p->verbosity_count = arg_verbosity1->count;
-        exitcode = E_SUCCESS_AND_DO;
+        if (nerrors1==0)
+        {
+            p->program_action = A_BROWSE;
+            //p->sim_string = strdup(arg_sim->sval[0]);
+            p->verbosity_count = arg_verbosity1->count;
+            exitcode = E_SUCCESS_AND_DO;
+        }
    }
-
    // interpret some special cases before we go through trouble of reading the config file
    if (help0->count > 0)
    {
@@ -12,17 +12,23 @@ typedef struct
    char* sim_string;
    int   program_action;
    int   program_state;
+    char* config_path;
+    char* gnuplot_file;
+    char* gnuplot_bin;
+    int gnuplotfound;

    bool  cli;
    bool  mqtt;
    bool  mysql;
    bool  simon;
    int   verbosity_count;
+    int err;

-    char* mysql_user;
-    char* mysql_serv;
-    char* mysql_dbnm;
-    char* mysql_pass;
+    char* db_user;
+    char* db_serv;
+    char* db_dbnm;
+    char* db_pass;
+    char* db_conn;

    Simulator sim;
    SimData* simdata;
@@ -33,7 +39,7 @@ Parameters;
 typedef enum
 {
    A_PLAY          = 0,
-    A_BROWSE        = 0
+    A_BROWSE        = 1,
 }
 ProgramAction;

@@ -45,6 +51,15 @@ typedef enum
 }
 ConfigError;

+typedef enum
+{
+    E_NO_ERROR         = 0,
+    E_BAD_CONFIG       = 1,
+    E_FAILED_DB_CONN   = 2,
+    E_DB_QUERY_FAIL    = 3,
+}
+GillesError;
+
 ConfigError getParameters(int argc, char** argv, Parameters* p);
 int freeparams(Parameters* p);
Author	SHA1	Message	Date
Paul Dino Jones	ee0315e620	Fix memory allocation on some queries	2024-02-03 12:55:54 -05:00
Paul Dino Jones	359f9b3a2d	Updated to latest simapi for tyre compound mapping on Assetto Corsa	2024-01-30 18:29:24 -05:00
Paul Dino Jones	18faa3a65a	Fix formatting on new code	2024-01-25 03:49:15 +00:00
Paul Dino Jones	66e9049891	Add more logging	2024-01-25 03:46:28 +00:00
Paul Dino Jones	415a83a1f5	Refactor query and telemetry functions into separate files	2024-01-24 18:33:35 +00:00
Paul Dino Jones	0ce4fb5c2f	Fix memory allocation for query	2024-01-20 13:57:05 -05:00
Paul Dino Jones	8b4c18ea4e	Fix compilation issue	2024-01-19 19:54:17 +00:00
Paul Dino Jones	32accbfb77	basic code organization changes mostly	2024-01-19 19:49:11 +00:00
Paul Dino Jones	109d7b1fed	Quick fixes on gameloop telemetry	2024-01-14 12:15:45 -05:00
Paul Dino Jones	7823e777d4	Make bold and add line	2024-01-13 17:44:09 +00:00
Paul Dino Jones	4772e759d4	Code to read in config for browse mode	2024-01-13 17:23:18 +00:00