/*

* kiki.c

*

* Created on: 2011-09-19

* Author: Anders Ma (xuejiao.ma@gmail.com)

*/

#include <stdlib.h>

#include <unistd.h>

#include <math.h>

#include <string.h>

#include <pthread.h>

#include <errno.h>

#include <sys/types.h>

#include <gtk/gtk.h>

#include <gdk/gdk.h>

#include <gdk/gdkkeysyms.h>

#include <glib-object.h>

#include <glib.h>

#include <time.h>

#include <signal.h>

#include <assert.h>

#include "kiki.h"

#include "mx.h"

#include "serial.h"

#include "hacker.h"

#define DEF_LOG_FOLDER "log"

#define MAX_HACKER_BACKLOG 10

#define ADD_ONE_WITH_WRAP_AROUND(value, top) \

do { if ((value) >= ((top) - 1)) (value) = 0; \

else (value)++; } while (0)

#define NICKNAME "Nick Name\n昵称"

#define PROFESSION "Profession\n职业"

#define WHY "Why coming here?\n为什么来这里？"

#define STARTTIME "Date/Time\n刷卡时间"

enum

{

COL_TIME = 0,

COL_PROF,

COL_NAME,

COL_WHY,

NUM_COLS

} ;

typedef enum

{

COLD_LOG = 0,

WARM_LOG

} log_t;

/*

* static variables

*/

/* System */

static int debug_enable = 0;

/* GTK+ */

static GtkBuilder *theXml;

static GtkWidget *theHackerList;

static GtkListStore *theHackerListStore;

static GtkTreeIter theHackerListIter;

/* communication */

static mx_t mx;

static serial_t serial;

static g_update_hacker_list = 0;

static hacker_list_t szdiy;

/* rfid processing ring buffer */

static hacker_t hacker_backlog[MAX_HACKER_BACKLOG];

static int hacker_process_index = 0;

static int hacker_present_index = 0;

static int hacker_number = 0;

/* Global variables */

int sighup_flag = 0; /* 1 => signal has happened, needs attention */

int sigchld_flag = 0;

/* Static function */

static void reload_configuration();

static void init_log(log_t log);

static gint rfid_id_callback (packet_t *p, void *arg);

void

DBG_PRINTF(const char *msg, ...)

{

va_list fmtargs;

char buf[200];

if (!debug_enable)

return;

va_start(fmtargs, msg);

vsnprintf(buf, sizeof(buf)-1, msg, fmtargs);

va_end(fmtargs);

printf("%s",buf);

}

char* strip(char *buffer){

int x;

int y;

int z;

if (buffer == NULL || buffer[0] == '\x0')

return buffer;

/* strip end of string */

y = (int)strlen(buffer);

for (x = y - 1; x >= 0; x--) {

if (buffer[x] == ' ' || buffer[x] == '\n' || buffer[x] == '\r' || buffer[x] == '\t' || buffer[x] == 13)

buffer[x]='\x0';

else

break;

}

/* strip beginning of string (by shifting) */

y = (int)strlen(buffer);

for (x = 0; x < y; x++) {

if (buffer[x] == ' ' || buffer[x] == '\n' || buffer[x] == '\r' || buffer[x] == '\t' || buffer[x] == 13)

continue;

else

break;

}

if (x > 0) {

for (z = x; z < y; z++)

buffer[z-x] = buffer[z];

buffer[y - x] = '\x0';

}

return buffer;

}

static void

enable_debug()

{

debug_enable = 1;

}

void sigchld(int dummy)

{

sigchld_flag = 1;

}

void sighup(int dummy)

{

sighup_flag = 1;

}

void init_signals(void)

{

struct sigaction sa;

sa.sa_handler = sigchld;

sigaction(SIGCHLD, &sa, NULL);

sa.sa_handler = sighup;

sigaction(SIGHUP, &sa, NULL);

}

static void usage ()

{

fprintf(stderr, "kiki [option]\n");

fprintf(stderr, "\t -d serial device (eg: /dev/ttyUSB0)\n");

fprintf(stderr, "\t -s serial speed (eg: 57600)\n");

fprintf(stderr, "\t -h this usage info\n");

fprintf(stderr, "\t -v output debug information\n");

}

/*

* destroy (program quits)

*/

void destroy (GtkWidget *widget, gpointer data)

{

serial_close(&serial);

mx_destroy(&mx);

hackers_destroy(&szdiy);

gtk_main_quit ();

}

static update_hacker_number(int n)

{

GtkLabel *label;

char buf[10];

snprintf(buf, sizeof(buf), "%d", n);

label = (GtkLabel*) GTK_WIDGET (gtk_builder_get_object (theXml, "labelHackerNumber"));

gtk_label_set_text (label, buf);

}

static gboolean idle_update_hacker_list(gpointer data)

{

pid_t pid;

int status;

char *argv[10];

time_t timep;

struct tm *p;

char tbuf[50], cmd[300], rfid[50], name[50];

int i;

char cwd[200];

time(&timep);

p = localtime(&timep);

packet_t pkt;

pkt.raw.rfid_id[0] = 0;

pkt.raw.rfid_id[1] = 0;

pkt.raw.rfid_id[2] = 0;

pkt.raw.rfid_id[3] = 0;

/* check if needing hackers reloading */

if (sighup_flag) {

sighup_flag = 0;

reload_configuration();

}

if (sigchld_flag) {

waitpid(-1, &status, 0);

}

sprintf(tbuf, "%4d-%2d-%2d/%2d:%2d:%2d", (1900+p->tm_year), 1 + p->tm_mon, p->tm_mday, p->tm_hour, p->tm_min, p->tm_sec);

/* special treatment for space 0->" 0"->"00" */

for (i = 0; i < strlen(tbuf); i++) {

if (tbuf[i] == ' ') {

tbuf[i] = '0';

}

}

if (hacker_present_index != hacker_process_index) {

/* Append a row and fill in some data */

gtk_list_store_append (theHackerListStore, &theHackerListIter);

gtk_list_store_set (theHackerListStore, &theHackerListIter,

COL_TIME, tbuf,

COL_NAME, hacker_backlog[hacker_process_index].name,

COL_PROF, hacker_backlog[hacker_process_index].prof,

COL_WHY, hacker_backlog[hacker_process_index].why,

-1);

/* invoke log.sh shell script */

getcwd(cwd, sizeof(cwd));

snprintf(cmd, sizeof(cmd), "%s/log.sh", cwd);

snprintf(rfid, sizeof(name), "%s", hacker_backlog[hacker_process_index].rfid);

snprintf(name, sizeof(name), "%s", hacker_backlog[hacker_process_index].name);

pid = fork();

if (pid == 0) {

argv[0] = strdup("/bin/bash");

argv[1] = strdup(cmd);

argv[2] = strdup(rfid);

argv[3] = strdup(name);

argv[4] = strdup(tbuf);

argv[5] = NULL;

execve("/bin/bash", argv, NULL);

_exit(1);

}

ADD_ONE_WITH_WRAP_AROUND(hacker_process_index, MAX_HACKER_BACKLOG);

}

return TRUE;

}

static void reload_configuration()

{

mx_rx_unregister(&mx, PTYPE_RFID_ID, rfid_id_callback);

hackers_reload(&szdiy);

init_log(WARM_LOG);

mx_rx_register(&mx, PTYPE_RFID_ID, rfid_id_callback, NULL);

}

static void init_log(log_t log)

{

int i;

FILE* fp;

char buf[200];

char filename[50], full_filename[100];

char *token;

hacker_t *hacker;

time_t timep;

struct tm *pt;

time(&timep);

pt = localtime(&timep);

/* handling login_time */

snprintf(filename, sizeof(filename), "%4d-%2d-%2d", (1900+pt->tm_year), 1 + pt->tm_mon, pt->tm_mday);

snprintf(full_filename, sizeof(full_filename), "%s/%s", DEF_LOG_FOLDER, filename);

/* special treatment for space 0->" 0"->"00" */

for (i = 0; i < strlen(full_filename); i++) {

if (full_filename[i] == ' ') {

full_filename[i] = '0';

}

}

fp = fopen(full_filename, "r");

if (!fp) {

//fprintf(stderr, "fopen %s error\n", full_filename);

return;

}

while (fgets(buf, sizeof(buf), fp)) {

// rfid

token = strtok(buf, "%");

if (token) {

hacker = search_hacker(&szdiy, token);

if (hacker) {

hacker->login++;

// name

token = strtok(NULL, "%");

// date/time

token = strtok(NULL, "%");

if (token) {

assert(hacker->login_time == NULL);

hacker->login_time = strdup(token);

}

}

}

if (hacker && log == COLD_LOG) {

/* Append a row and fill in some data */

gtk_list_store_append (theHackerListStore, &theHackerListIter);

gtk_list_store_set (theHackerListStore, &theHackerListIter,

COL_TIME, hacker->login_time,

COL_NAME, hacker->name,

COL_PROF, hacker->prof,

COL_WHY, hacker->why,

-1);

update_hacker_number(++hacker_number);

}

}

fclose(fp);

}

static GtkTreeModel* create_and_fill_model (void)

{

theHackerListStore = gtk_list_store_new (NUM_COLS, G_TYPE_STRING,

G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);

return GTK_TREE_MODEL (theHackerListStore);

}

static GtkWidget* create_hacker_mvc (void)

{

GtkTreeViewColumn *col;

GtkCellRenderer *renderer;

GtkTreeModel *model;

GtkWidget *view;

view = GTK_WIDGET (gtk_builder_get_object (theXml, "treeview1"));

/* --- Column #1 --- */

renderer = gtk_cell_renderer_text_new ();

gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view),

-1,

STARTTIME,

renderer,

"text", COL_TIME,

NULL);

/* --- Column #2 --- */

renderer = gtk_cell_renderer_text_new ();

gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view),

-1,

PROFESSION,

renderer,

"text", COL_PROF,

NULL);

/* --- Column #3 --- */

renderer = gtk_cell_renderer_text_new ();

gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view),

-1,

NICKNAME,

renderer,

"text", COL_NAME,

NULL);

/* --- Column #4 --- */

renderer = gtk_cell_renderer_text_new ();

gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view),

-1,

WHY,

renderer,

"text", COL_WHY,

NULL);

theHackerListStore = gtk_list_store_new (NUM_COLS, G_TYPE_STRING,

G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);

model = GTK_TREE_MODEL (theHackerListStore);

gtk_tree_view_set_model (GTK_TREE_VIEW (view), model);

g_object_unref (model); /* destroy model automatically with view */

return view;

}

static gboolean ping_rfid (gpointer data)

{

packet_t pkt;

char cmd[5] = {0xaa, 0xbb, 0x02, 0x20, 0x22};

//update_hacker_number(++hacker_number);

pkt.type = PTYPE_RFID_CMD;

memcpy(pkt.raw.rfid_cmd, cmd, 5);

mx_tx_packet(&mx, &pkt);

return TRUE;

}

static gint rfid_id_callback (packet_t *p, void *arg)

{

int i;

static int counter = 0;

hacker_t* hacker;

char rfid[20], tbuf[50];

time_t timep;

struct tm *pt;

time(&timep);

pt = localtime(&timep);

g_printf("[rfid %d ] ", counter++);

for (i = 0; i < 5; i++) {

g_printf("%x,", p->raw.rfid_id[i]);

}

g_printf("\n");

snprintf(rfid, sizeof(rfid), "%2x%2x%2x%2x%2x", p->raw.rfid_id[0], p->raw.rfid_id[1],

p->raw.rfid_id[2], p->raw.rfid_id[3], p->raw.rfid_id[4]);

/* special treatment for space 0->" 0"->"00" */

for (i = 0; i < 10; i++) {

if (rfid[i] == ' ') {

rfid[i] = '0';

}

}

hacker = search_hacker(&szdiy, rfid);

if (hacker && !hacker->login++) {

/* handling login_time */

sprintf(tbuf, "%4d-%2d-%2d/%2d:%2d:%2d", (1900+pt->tm_year), 1 + pt->tm_mon,

pt->tm_mday, pt->tm_hour, pt->tm_min, pt->tm_sec);

/* special treatment for space 0->" 0"->"00" */

for (i = 0; i < strlen(tbuf); i++) {

if (tbuf[i] == ' ') {

tbuf[i] = '0';

}

}

if (!hacker->login_time) { /* double check */

hacker->login_time = strdup(tbuf);

}

hacker_backlog[hacker_present_index].rfid = hacker->rfid;

hacker_backlog[hacker_present_index].name = hacker->name;

hacker_backlog[hacker_present_index].prof = hacker->prof;

hacker_backlog[hacker_present_index].why = hacker->why;

hacker_backlog[hacker_present_index].login_time = hacker->login_time;

update_hacker_number(++hacker_number);

ADD_ONE_WITH_WRAP_AROUND(hacker_present_index, MAX_HACKER_BACKLOG);

}

}

void show_warning(gpointer window, const gchar *msg)

{

GtkWidget *dialog;

dialog = gtk_message_dialog_new(window,

GTK_DIALOG_DESTROY_WITH_PARENT,

GTK_MESSAGE_WARNING,

GTK_BUTTONS_OK,

"%s",

msg);

gtk_window_set_title(GTK_WINDOW(dialog), "Warning");

gtk_dialog_run(GTK_DIALOG(dialog));

gtk_widget_destroy(dialog);

}

/*

* show new dialog

*/

void on_new (GtkWidget* widget, gpointer data)

{

GtkDialog *new;

new = GTK_DIALOG (gtk_builder_get_object (theXml, "newdialog"));

gtk_dialog_run(new);

}

void on_newDialogClose(GtkWidget* widget, gpointer data)

{

GtkDialog *new;

new = GTK_DIALOG (gtk_builder_get_object (theXml, "newdialog"));

gtk_widget_hide(GTK_WIDGET(new));

}

/*

* show about dialog

*/

void on_about (GtkWidget* widget, gpointer data)

{

GtkDialog *about;

about = GTK_DIALOG (gtk_builder_get_object (theXml, "aboutdialog"));

gtk_dialog_run(about);

gtk_widget_hide(GTK_WIDGET(about));

}

void on_newDialogButtonNew_clicked(GtkWidget* widget, gpointer data)

{

hacker_t* hacker;

GtkEntry *rfid;

GtkEntry *nickname;

GtkEntry *prof;

GtkEntry *why;

GtkEntry *email;

GtkEntry *mac;

rfid = GTK_ENTRY (gtk_builder_get_object (theXml, "newDialogEntryRFID"));

nickname = GTK_ENTRY (gtk_builder_get_object (theXml, "newDialogEntryNickname"));

prof = GTK_ENTRY (gtk_builder_get_object (theXml, "newDialogEntryProf"));

why = GTK_ENTRY (gtk_builder_get_object (theXml, "newDialogEntryWhy"));

email = GTK_ENTRY (gtk_builder_get_object (theXml, "newDialogEntryEmail"));

mac = GTK_ENTRY (gtk_builder_get_object (theXml, "newDialogEntryMAC"));

if (strlen(gtk_entry_get_text (nickname)) == 0 ) {

show_warning((GtkWidget*)gtk_builder_get_object (theXml, "newdialog"),

"Nickname is empty!");

return;

}

if (strchr((char*)gtk_entry_get_text (nickname), ' ')) {

show_warning((GtkWidget*)gtk_builder_get_object (theXml, "newdialog"),

"Nickname can't contain space character!");

return;

}

hacker = search_hacker(&szdiy, (char*)gtk_entry_get_text (rfid));

if (hacker != NULL) {

free(hacker->name);

hacker->name = strdup(gtk_entry_get_text (nickname));

free(hacker->prof);

hacker->prof = strdup(gtk_entry_get_text (prof));

free(hacker->why);

hacker->why = strdup(gtk_entry_get_text (why));

free(hacker->email);

hacker->email = strdup(gtk_entry_get_text (email));

free(hacker->mac);

hacker->mac = strdup(gtk_entry_get_text (mac));

} else {

hacker = new_hacker(&szdiy);

hacker->rfid = strdup((char*)(gtk_entry_get_text (rfid)));

hacker->name = strdup((char*)(gtk_entry_get_text (nickname)));

hacker->prof = strdup(gtk_entry_get_text (prof));

hacker->why = strdup(gtk_entry_get_text (why));

hacker->email = strdup(gtk_entry_get_text (email));

hacker->mac = strdup(gtk_entry_get_text (mac));

}

hackers_save(&szdiy);

reload_configuration();

}

void on_newDialogButtonSign_clicked(GtkWidget* widget, gpointer data)

{

hacker_t* hacker;

GtkEntry *rfid;

int i;

char tbuf[50];

time_t timep;

struct tm *pt;

// to be changed to "newDialogEntryNickRFID", while RFID cards are available

rfid = GTK_ENTRY (gtk_builder_get_object (theXml, "newDialogEntryRFID"));

if (strlen(gtk_entry_get_text (rfid)) == 0 ) {

show_warning((GtkWidget*)gtk_builder_get_object (theXml, "newdialog"),

"Nickname is empty!");

return;

}

if (strchr((char*)gtk_entry_get_text (rfid), ' ')) {

show_warning((GtkWidget*)gtk_builder_get_object (theXml, "newdialog"),

"Nickname can't contain space character!");

return;

}

hacker = search_hacker(&szdiy, (char*)gtk_entry_get_text (rfid));

if (hacker != NULL && !hacker->login++) {

time(&timep);

pt = localtime(&timep);

/* handling login_time */

sprintf(tbuf, "%4d-%2d-%2d/%2d:%2d:%2d", (1900+pt->tm_year), 1 + pt->tm_mon,

pt->tm_mday, pt->tm_hour, pt->tm_min, pt->tm_sec);

/* special treatment for space 0->" 0"->"00" */

for (i = 0; i < strlen(tbuf); i++) {

if (tbuf[i] == ' ') {

tbuf[i] = '0';

}

}

if (!hacker->login_time) { /* double check */

hacker->login_time = strdup(tbuf);

}

hacker_backlog[hacker_present_index].rfid = hacker->rfid;

hacker_backlog[hacker_present_index].name = hacker->name;

hacker_backlog[hacker_present_index].prof = hacker->prof;

hacker_backlog[hacker_present_index].why = hacker->why;

hacker_backlog[hacker_present_index].login_time = hacker->login_time;

update_hacker_number(++hacker_number);

ADD_ONE_WITH_WRAP_AROUND(hacker_present_index, MAX_HACKER_BACKLOG);

}

}

/*

* main

*/

int main (int argc, char *argv[])

{

GtkWidget *mainWindow;

GtkWidget *copterDrawingArea;

extern int optind;

extern int optopt;

extern int opterr;

extern int optreset;

char *optstr="d:s:h:v";

char *sdev = NULL;

int sspeed = -1;

int opt = 0;

/*

* Init argument control

*/

opt = getopt( argc, argv, optstr);

while( opt != -1 ) {

switch( opt ) {

case 'd':

sdev = optarg;

break;

case 's':

sspeed = atoi(optarg);

break;

case 'h':

usage();

return 0;

case 'v':

enable_debug();

break;

default:

break;

}

opt = getopt(argc, argv, optstr);

}

if (!g_thread_supported ()){ g_thread_init (NULL); }

gdk_threads_init ();

gdk_threads_enter ();

/*

* Init GTK+ and GtkGLExt.

*/

gtk_init (&argc, &argv);

/*

* Load the GTK interface.

*/

theXml = gtk_builder_new ();

gtk_builder_add_from_file (theXml, "kiki.glade", NULL);

if (theXml == NULL)

{

g_critical ("Failed to load an initialise the GTK file.\n");

return -1;

}

/*

* Get the top-level window reference from loaded Glade file.

*/

mainWindow = GTK_WIDGET (gtk_builder_get_object (theXml, "windowMain"));

// Set unassigned widgets to get handled automatically by the window manager.

gtk_container_set_reallocate_redraws (GTK_CONTAINER (mainWindow), TRUE);

/*

* Get the window manager to connect any assigned signals in the loaded Glade file to our coded functions.

*/

gtk_builder_connect_signals (theXml, NULL);

/*

* Init hackers information

*/

hackers_init(&szdiy);

theHackerList = create_hacker_mvc();

init_log(COLD_LOG);

/*

* Init serial & mx

*/

mx_init(&mx, serial_tx_data, (void*)&serial);

mx_rx_register(&mx, PTYPE_RFID_ID, rfid_id_callback, NULL);

serial_init(&serial, mx_rx_data, &mx);

if (!sdev)

sdev = "/dev/ttyUSB0";

if (sspeed == -1)

sspeed = 19200;

serial_open(&serial, sdev, sspeed);

init_signals();

/*

* Show main window.

*/

gtk_widget_show (mainWindow);

/*

* Init timer

*/

g_timeout_add (1000, ping_rfid, NULL);

g_idle_add ((GtkFunction)idle_update_hacker_list, NULL);

// Run the window manager loop.

gtk_main ();

gdk_threads_leave ();

return 0;

}