BOOL WCTLbIsDuplicate (PSCache pCache, PS802_11Header pMACHeader)
{
UINT uIndex;
UINT ii;
PSCacheEntry pCacheEntry;
if (IS_FC_RETRY(pMACHeader)) {
uIndex = pCache->uInPtr;
for (ii = 0; ii < DUPLICATE_RX_CACHE_LENGTH; ii++) {
pCacheEntry = &(pCache->asCacheEntry[uIndex]);
if ((pCacheEntry->wFmSequence == pMACHeader->wSeqCtl) &&
(IS_ETH_ADDRESS_EQUAL (&(pCacheEntry->abyAddr2[0]), &(pMACHeader->abyAddr2[0])))
) {
/* Duplicate match */
return TRUE;
}
ADD_ONE_WITH_WRAP_AROUND(uIndex, DUPLICATE_RX_CACHE_LENGTH);
}
}
/* Not fount in cache - insert */
pCacheEntry = &pCache->asCacheEntry[pCache->uInPtr];
pCacheEntry->wFmSequence = pMACHeader->wSeqCtl;
memcpy(&(pCacheEntry->abyAddr2[0]), &(pMACHeader->abyAddr2[0]), ETH_ALEN);
ADD_ONE_WITH_WRAP_AROUND(pCache->uInPtr, DUPLICATE_RX_CACHE_LENGTH);
return FALSE;
}
bool WCTLbIsDuplicate (PSCache pCache, struct ieee80211_hdr *pMACHeader)
{
unsigned int uIndex;
unsigned int ii;
PSCacheEntry pCacheEntry;
if (IS_FC_RETRY(pMACHeader)) {
uIndex = pCache->uInPtr;
for (ii = 0; ii < DUPLICATE_RX_CACHE_LENGTH; ii++) {
pCacheEntry = &(pCache->asCacheEntry[uIndex]);
if ((pCacheEntry->wFmSequence == pMACHeader->seq_ctrl) &&
(!compare_ether_addr(&(pCacheEntry->abyAddr2[0]),
&(pMACHeader->addr2[0]))) &&
(LOBYTE(pCacheEntry->wFrameCtl) == LOBYTE(pMACHeader->frame_control))
) {
/* Duplicate match */
return true;
}
ADD_ONE_WITH_WRAP_AROUND(uIndex, DUPLICATE_RX_CACHE_LENGTH);
}
}
/* Not found in cache - insert */
pCacheEntry = &pCache->asCacheEntry[pCache->uInPtr];
pCacheEntry->wFmSequence = pMACHeader->seq_ctrl;
memcpy(&(pCacheEntry->abyAddr2[0]), &(pMACHeader->addr2[0]), ETH_ALEN);
pCacheEntry->wFrameCtl = pMACHeader->frame_control;
ADD_ONE_WITH_WRAP_AROUND(pCache->uInPtr, DUPLICATE_RX_CACHE_LENGTH);
return false;
}
BOOL WCTLbIsDuplicate (PSCache pCache, PS802_11Header pMACHeader)
{
unsigned int uIndex;
unsigned int ii;
PSCacheEntry pCacheEntry;
if (IS_FC_RETRY(pMACHeader)) {
uIndex = pCache->uInPtr;
for (ii = 0; ii < DUPLICATE_RX_CACHE_LENGTH; ii++) {
pCacheEntry = &(pCache->asCacheEntry[uIndex]);
if ((pCacheEntry->wFmSequence == pMACHeader->wSeqCtl) &&
(!compare_ether_addr(&(pCacheEntry->abyAddr2[0]),
&(pMACHeader->abyAddr2[0]))) &&
(LOBYTE(pCacheEntry->wFrameCtl) == LOBYTE(pMACHeader->wFrameCtl))
) {
/* Duplicate match */
return TRUE;
}
ADD_ONE_WITH_WRAP_AROUND(uIndex, DUPLICATE_RX_CACHE_LENGTH);
}
}
/* Not found in cache - insert */
pCacheEntry = &pCache->asCacheEntry[pCache->uInPtr];
pCacheEntry->wFmSequence = pMACHeader->wSeqCtl;
memcpy(&(pCacheEntry->abyAddr2[0]), &(pMACHeader->abyAddr2[0]), ETH_ALEN);
pCacheEntry->wFrameCtl = pMACHeader->wFrameCtl;
ADD_ONE_WITH_WRAP_AROUND(pCache->uInPtr, DUPLICATE_RX_CACHE_LENGTH);
return FALSE;
}
/*
* parse input packet and update pertinent variables
*/
gint parse_packet(packet_t *p, void *arg)
{
int i;
float adc, vol;
float accx, accy, accz;
if (p->type == ANALOG_NAME_RESPONSE) {
// to be continued. @_@
} else if (p->type == ANALOG_DATA_RESPONSE) {
// update analog data buffer
memcpy(&acc_data[accdata_present_index],
&p->raw.analog_data, sizeof(analog_data_t));
ADD_ONE_WITH_WRAP_AROUND(accdata_present_index, MAX_ANALOGDATA_ENTRY);
memcpy(&gyro_data[gyrodata_present_index],
&p->raw.analog_data, sizeof(analog_data_t));
ADD_ONE_WITH_WRAP_AROUND(gyrodata_present_index, MAX_ANALOGDATA_ENTRY);
// attitude
attitude.acc_crt_x = p->raw.analog_data.value[ACCX_CHANNEL];
attitude.acc_crt_y = p->raw.analog_data.value[ACCY_CHANNEL];
attitude.acc_crt_z = p->raw.analog_data.value[ACCZ_CHANNEL];
attitude_by_acc(&attitude);
}
return 0;
}
bool WCTLbIsDuplicate (PSCache pCache, PS802_11Header pMACHeader)
{
unsigned int uIndex;
unsigned int ii;
PSCacheEntry pCacheEntry;
if (IS_FC_RETRY(pMACHeader)) {
uIndex = pCache->uInPtr;
for (ii = 0; ii < DUPLICATE_RX_CACHE_LENGTH; ii++) {
pCacheEntry = &(pCache->asCacheEntry[uIndex]);
if ((pCacheEntry->wFmSequence == pMACHeader->wSeqCtl) &&
(!compare_ether_addr(&(pCacheEntry->abyAddr2[0]), &(pMACHeader->abyAddr2[0])))
) {
return true;
}
ADD_ONE_WITH_WRAP_AROUND(uIndex, DUPLICATE_RX_CACHE_LENGTH);
}
}
pCacheEntry = &pCache->asCacheEntry[pCache->uInPtr];
pCacheEntry->wFmSequence = pMACHeader->wSeqCtl;
memcpy(&(pCacheEntry->abyAddr2[0]), &(pMACHeader->abyAddr2[0]), ETH_ALEN);
ADD_ONE_WITH_WRAP_AROUND(pCache->uInPtr, DUPLICATE_RX_CACHE_LENGTH);
return false;
}
static gboolean update_gyros_graph(gpointer data)
{
graph_t *g = (graph_t*)data;
if (gyrodata_present_index != gyrodata_process_index) {
graph_force_update(g);
ADD_ONE_WITH_WRAP_AROUND(gyrodata_process_index, MAX_ANALOGDATA_ENTRY);
}
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);
}
}
int vnt_schedule_command(struct vnt_private *priv, enum vnt_cmd command)
{
if (priv->free_cmd_queue == 0)
return false;
priv->cmd_queue[priv->cmd_enqueue_idx] = command;
ADD_ONE_WITH_WRAP_AROUND(priv->cmd_enqueue_idx, CMD_Q_SIZE);
priv->free_cmd_queue--;
if (priv->cmd_running == false)
vnt_cmd_complete(priv);
return true;
}
static int vnt_cmd_complete(struct vnt_private *priv)
{
priv->command_state = WLAN_CMD_IDLE;
if (priv->free_cmd_queue == CMD_Q_SIZE) {
/* Command Queue Empty */
priv->cmd_running = false;
return true;
}
priv->command = priv->cmd_queue[priv->cmd_dequeue_idx];
ADD_ONE_WITH_WRAP_AROUND(priv->cmd_dequeue_idx, CMD_Q_SIZE);
priv->free_cmd_queue++;
priv->cmd_running = true;
switch (priv->command) {
case WLAN_CMD_INIT_MAC80211:
priv->command_state = WLAN_CMD_INIT_MAC80211_START;
break;
case WLAN_CMD_TBTT_WAKEUP:
priv->command_state = WLAN_CMD_TBTT_WAKEUP_START;
break;
case WLAN_CMD_BECON_SEND:
priv->command_state = WLAN_CMD_BECON_SEND_START;
break;
case WLAN_CMD_SETPOWER:
priv->command_state = WLAN_CMD_SETPOWER_START;
break;
case WLAN_CMD_CHANGE_ANTENNA:
priv->command_state = WLAN_CMD_CHANGE_ANTENNA_START;
break;
default:
break;
}
vnt_cmd_timer_wait(priv, 0);
return true;
}
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;
}
