20160127_jeffrey - silenceuncrio/diary GitHub Wiki

/* standard includes */
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>

/* json-c (https://github.com/json-c/json-c) */
#include <json-c/json.h>

/* libcurl (http://curl.haxx.se/libcurl/c) */
#include <curl/curl.h>

#include "timecost_2.h"

#include "database_2.h"



/* holder for curl fetch */
struct curl_fetch_st {
    char *payload;
    size_t size;
};

/* callback for curl fetch */
size_t curl_callback (void *contents, size_t size, size_t nmemb, void *userp) {
    size_t realsize = size * nmemb;                             /* calculate buffer size */
    struct curl_fetch_st *p = (struct curl_fetch_st *) userp;   /* cast pointer to fetch struct */

    /* expand buffer */
    p->payload = (char *) realloc(p->payload, p->size + realsize + 1);

    /* check buffer */
    if (p->payload == NULL) {
      /* this isn't good */
      fprintf(stderr, "ERROR: Failed to expand buffer in curl_callback");
      /* free buffer */
      free(p->payload);
      /* return */
      return -1;
    }

    /* copy contents to buffer */
    memcpy(&(p->payload[p->size]), contents, realsize);

    /* set new buffer size */
    p->size += realsize;

    /* ensure null termination */
    p->payload[p->size] = 0;

    /* return size */
    return realsize;
}

/* fetch and return url body via curl */
CURLcode curl_fetch_url(CURL *ch, const char *url, struct curl_fetch_st *fetch) {
    CURLcode rcode;                   /* curl result code */

    /* init payload */
    fetch->payload = (char *) calloc(1, sizeof(fetch->payload));

    /* check payload */
    if (fetch->payload == NULL) {
        /* log error */
        fprintf(stderr, "ERROR: Failed to allocate payload in curl_fetch_url");
        /* return error */
        return CURLE_FAILED_INIT;
    }

    /* init size */
    fetch->size = 0;

    /* set url to fetch */
    curl_easy_setopt(ch, CURLOPT_URL, url);

    /* set calback function */
    curl_easy_setopt(ch, CURLOPT_WRITEFUNCTION, curl_callback);

    /* pass fetch struct pointer */
    curl_easy_setopt(ch, CURLOPT_WRITEDATA, (void *) fetch);

    /* set default user agent */
    curl_easy_setopt(ch, CURLOPT_USERAGENT, "libcurl-agent/1.0");

    /* set timeout */
    curl_easy_setopt(ch, CURLOPT_TIMEOUT, 5);

    /* enable location redirects */
    curl_easy_setopt(ch, CURLOPT_FOLLOWLOCATION, 1);

    /* set maximum allowed redirects */
    curl_easy_setopt(ch, CURLOPT_MAXREDIRS, 1);

    /* fetch the url */
    rcode = curl_easy_perform(ch);

    /* return */
    return rcode;
}



static int _key2string(json_object *obj, const char *key, char *value) {
    json_object *j;
    if (!json_object_object_get_ex(obj, key, &j)) {
        printf("Error: %s(%s) fail\n", __FUNCTION__, key);
        return -1;
    }

    strcpy(value, json_object_get_string(j));
    printf("%s: %s\n", key, value);
    return 0;
}



static int _key2obj(json_object *obj, const char *key, json_object **keyObj) {
    if (!json_object_object_get_ex(obj, key, keyObj)) {
        printf("Error: %s(%s) fail\n", __FUNCTION__, key);
        return -1;
    }

    printf("%s: %s\n", key, json_object_to_json_string(*keyObj));
    return 0;
}



static int _hasKey(json_object *obj, const char *key) {
    json_object *j;
    if (!json_object_object_get_ex(obj, key, &j)) {
        printf("Error: %s(%s) fail\n", __FUNCTION__, key);
        return 0;
    }
    return 1;
}



int select_inactive_callback(void *NotUsed, int argc, char **argv, char **azColName) {
    int i;
    NotUsed = 0;
    
    for (i = 0; i < argc; i++) {
        printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
    }
    printf("\n");
   
    return 0;
}



int main(int argc, char *argv[]) {
    CURL *ch;                                               /* curl handle */
    CURLcode rcode;                                         /* curl result code */

    json_object *json;                                      /* json post body */
    enum json_tokener_error jerr = json_tokener_success;    /* json parse error */

    struct curl_fetch_st curl_fetch;                        /* curl fetch struct */
    struct curl_fetch_st *cf = &curl_fetch;                 /* pointer to fetch struct */


    Timecost.start();



    Db.open();
    Db.whiteBoxes.select_inactive(select_inactive_callback);
    Db.close();


    
    Timecost.stop();
    Timecost.report();

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <sys/time.h>






typedef struct {

    void    (*start)    (void);
    void    (*stop)     (void);
    void    (*report)   (void);

} timecost_t;

extern timecost_t Timecost;

#include "timecost_2.h"



struct timeval t1, t2;
double timecost;



void timecost_start() {
    gettimeofday(&t1, NULL);
}



void timecost_stop() {
    gettimeofday(&t2, NULL);
}

void timecost_report() {
    timecost = (t2.tv_sec - t1.tv_sec) * 1000.0;    // sec to ms
    timecost += (t2.tv_usec - t1.tv_usec) / 1000.0; // us to ms
    printf("Code time cost: %f\n", timecost);
}


timecost_t Timecost = {
    .start  = timecost_start,
    .stop   = timecost_stop,
    .report = timecost_report,
};

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <sqlite3.h>






typedef struct {

    int     (*select_inactive)
            (int (*callback)(void*,int,char**,char**));

} db_whiteBoxes_t;



typedef struct {

    int     (*open)();
    void    (*close)();

    int     (*select_inactive_from_whiteBoxes)
            (int (*callback)(void*,int,char**,char**));

    int     (*insert_into_openDetectors)
            (const char *OpenConfig_, const char *OpenStatus_, int ThingId);

    db_whiteBoxes_t whiteBoxes;

} db_t;



extern db_t Db;

#include "database_2.h"



sqlite3 *Database;



int database_select_inactive_from_whiteBoxes(int (*callback)(void*,int,char**,char**)) {
    char sql[256];
    sprintf(sql, 
        "SELECT * FROM WhiteBoxes WHERE WhiteBoxActive=0;"
        );

    char *err_msg = 0;
    if (SQLITE_OK != sqlite3_exec(Database, sql, callback, 0, &err_msg)) {
        fprintf(stderr, "SQL error: %s\n", err_msg);
        sqlite3_free(err_msg);
        return -1;
    }

    return sqlite3_last_insert_rowid(Database);
}



int database_insert_into_openDetectors(const char *OpenConfig_, const char *OpenStatus_, int ThingId) {
    char sql[256];
    sprintf(sql, 
        "INSERT INTO OpenDetectors(OpenConfig_, OpenStatus_, ThingId)"
        "VALUES ('%s', '%s', %d);"
        , OpenConfig_, OpenStatus_, ThingId);

    char *err_msg = 0;
    if (SQLITE_OK != sqlite3_exec(Database, sql, 0, 0, &err_msg)) {
        fprintf(stderr, "SQL error: %s\n", err_msg);
        sqlite3_free(err_msg);
        return -1;
    }

    return sqlite3_last_insert_rowid(Database);
}



int database_insert_into_lightDetectors(const char *LightConfig_, const char *LightStatus_, int ThingId) {
    char sql[256];
    sprintf(sql, 
        "INSERT INTO LightDetectors(LightConfig_, LightStatus_, ThingId)"
        "VALUES ('%s', '%s', %d);"
        , LightConfig_, LightStatus_, ThingId);

    char *err_msg = 0;
    if (SQLITE_OK != sqlite3_exec(Database, sql, 0, 0, &err_msg)) {
        fprintf(stderr, "SQL error: %s\n", err_msg);
        sqlite3_free(err_msg);
        return -1;
    }

    return sqlite3_last_insert_rowid(Database);
}



int database_insert_into_things(const char *ThingType, const char *ThingStatus_, int BoxId) {
    char sql[256];
    sprintf(sql, 
        "INSERT INTO Things(ThingType, ThingStatus_, BoxId) "
        "VALUES ('%s', '%s', %d);"
        , ThingType, ThingStatus_, BoxId);

    char *err_msg = 0;
    if (SQLITE_OK != sqlite3_exec(Database, sql, 0, 0, &err_msg)) {
        fprintf(stderr, "Failed to insert into Things\n");
        fprintf(stderr, "SQL error: %s\n", err_msg);
        sqlite3_free(err_msg);
        return -1;
    }

    return sqlite3_last_insert_rowid(Database);
}



int database_insert_into_boxes(const char *BoxName, const char *BoxLocation, const char *BoxConfig_) {
    char sql[256];
    sprintf(sql, 
        "INSERT INTO Boxes(BoxName, BoxLocation, BoxConfig_) "
        "VALUES ('%s', '%s', '%s');"
        , BoxName, BoxLocation, BoxConfig_);

    char *err_msg = 0;
    if (SQLITE_OK != sqlite3_exec(Database, sql, 0, 0, &err_msg)) {
        fprintf(stderr, "SQL error: %s\n", err_msg);
        sqlite3_free(err_msg);
        return -1;
    }

    return sqlite3_last_insert_rowid(Database);
}



int database_open() {
    if (SQLITE_OK != sqlite3_open("iot.db", &Database)) {
        fprintf(stderr, "Cannot open database: %s\n", sqlite3_errmsg(Database));
        sqlite3_close(Database);
        return -1;
    }
}



void database_close() {
    sqlite3_close(Database);
}






db_t Db = {
    .open                               = database_open,

    .close                              = database_close,

    .select_inactive_from_whiteBoxes    = database_select_inactive_from_whiteBoxes,

	.insert_into_openDetectors          = database_insert_into_openDetectors,

    .whiteBoxes.select_inactive    = database_select_inactive_from_whiteBoxes,
};