Lab46 Wiki

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
=====HPC 1=====

====August 31, 2015====

HPC0 has definitely had the most eventful first week of any class i have been apart of at CCC. Starting out the semester with missing computers was interesting to say the least. This worked out alright in the end as it gave us time to rearrange the room into four separate pod stations to house the new computers. The new computers are great, especially the "upgraded" 4GB of flash. 


====September 07, 2015====

We have slowly been working out the kinks in the new POD set up. We were able to give each pod a host name based up its MAC address! This required Brian and I to copy all of the MACs down and submit them to Matt to add to the router. We also fixed an issue, thanks to Andrew, with Vim not using backspace! More bug searching/fixing to come!

====September 14, 2015====

I have been brain storming ideas for a cool HPC0 project. Matt came up with a few really cool ones today such as a CLI based library system for checking out books from the lairs collection, installing Linux on multiple machines that are all different architectures (Some of them are powerpc, ARM, and MIPS). This one was appealing to me as i really did enjoy using the powerpc mac mini in the old lair and would like to restore its functionality. We also discussed making a weather display for the new lair. This would allow us to see graphical data in real time to veiw what the weather is doing in our local area. This may be a really cool project as the winter season approaches and inevitable snow days occur. 

====September 21, 2015====

Today we finally rolled out an AWESOME new version of the pod BSD image. Matt, Brian, and i got every pod set up to copy the new image to the pods 4GB of internal flash storage. We were extremely leery of how the network would handle this mass roll out. We were astounded to see everything going smooth! Each machine was using about 12MB of network bandwidth. This is roughly saturating 100mbps speeds! Seeing how each switch has a 1GB up-link and each pod station has about 6 machines we were achieving some very impressive speeds for the low end hardware we have in place. This new image now allowed us to take advantage of the two extra gigabytes of flash storage we unexpectedly received in each pod station! Each station now has a free space of 1.7GB. This is much better than the 70MB we had with the previous version of the pod image. We are still experiencing some hanging issues up on boot but we are close to solving the issue!

====September 28, 2015====

Currently i have been thinking of projects that i can combine with my other existing courses to help save time and effort. The main class i have in mind is datacomm. Matt's guidelines were that the project had to have some sort of inspection and processing of data from a source. My first idea was to use wireshark & snort to filter local area network traffic and identify a specific pattern of packets in conjunction with a specific attack type. I am currently thinking of using ARP spoofing as the pattern i want to detect. This is for two reasons. first and foremost ARP spoofing is an extremely simple yet effective attack that works on a LAN level only. Being able to avoid this easy attack on your local area network can save many headaches. Secondly ARP packets are extremely unique in comparison to others. This would allow for very easy filtering and capture of these packets only. 

====October 5, 2015====

My arp spoofing project is under way! Currently I have two Windows 10 virtual machines set up and running cain and able. This is the program I will be using to do the ARP spoofing attacks. I have been looking into Linux options for ARP spoofing as well as creating my own programs to do this. For now this is the quickest option. The next step will be to set up a service that is vulnerable to ARP spoofing to demonstrate its uses. For this i have been considering an apache web server using http instead of https. This would allow me to see if the spoofing actually worked to capture the unencrypted traffic sent between the web server and the spoofed host. to capture this traffic i will use wireshark. This will give me a pcap format file to sift through and find arp packets. From there i will creat a script that can take in a MAC address and search for arp packets that match the address. As i write this i am thinking of issues with this and maybe i need to do some more brainstorming and testing. BLAGHHH.
=====Data Structures=====

====August 31, 2015====

Data structures is a hard class to take with out computers... 

This week was very uneventful due to the above statement. Matt reviewed some topics from our past prerequisite classes to help us get up to pace with what will be needed in our first project. This had me inspired and i started working! 

<code c>
#include <stdio.h>

int main()
{
    int choice = 0;
    printf ("1) Build List\n");
    printf ("2) Display List\n");
    printf ("3) Instert Into List\n");
    printf ("4) Append Into List\n");
    printf ("5) Obtain From List\n");
    printf ("6) Clear List\n");
    printf ("7) Quit\n");
return 0;
}
</code>

Underwhelming! :D


====September 07, 2015====
<code c>
#include <stdio.h>

int main(){
    int test [20];
    int choice = 0;
    do{
        printf ("1) Build List\n");
        printf ("2) Display List\n");
        printf ("3) Instert Into List\n");
        printf ("4) Append Into List\n");
        printf ("5) Obtain From List\n");
        printf ("6) Clear List\n");
        printf ("7) Quit\n");
        printf ("Enter option: ");    

        scanf ("%d", &choice);
        
        if (choice > 7){
            printf ("Non-existent Option\n");
        }    
    
        if (choice == 1){
            printf ("enter numbers: ");
            int number = 0;
            int index = 0;
            int stop = -1;
            do{
                if (index == 19){
                    test[index] = stop;
                    printf ("number limit reached\n");
                    break;
                } else {  
                    scanf ("%d", &number );
                    test[index] = number;
                    index++;
                }    
            } while (number != -1);
        
        
        } else if (choice == 2){
            int i;
            for (i = 0; i <= 19; i++){
                int at = test[i];
                if (at == -1){
                    printf ("# -1 @ array index %d\n", i);
                    break;
                } else {  
                    printf ("# %d @ array index %d\n", at,i);    
                }
            }
        } else if (choice == 3){
            int nv, ai, in;
            printf ("enter new value: ");
            scanf ("%d", &nv);
            printf ("enter array index: ");
            scanf ("%d", &ai);
            printf ("nv %d ai %d\n", nv,ai);
            for (in =0; i <19
        }
    } while (choice != 7);
    return 0;
}
</code>

dsi0 is coming along and should be done tonight! W00t W00t.

====September 14, 2015====

Here is my finished dsi0 source code!
<code c>
                // Author: Dan Shadeck
// Date: 09/09/2014
// Class: CSCS2320
// Project: dsi0
#include <stdio.h>

int main(){
    int test [20];
    int choice = 0;
        int masterindex = 0;
    do{
        printf ("1) Build List\n");
        printf ("2) Display List\n");
        printf ("3) Instert Into List\n");
        printf ("4) Append Into List\n");
        printf ("5) Obtain From List\n");
        printf ("6) Clear List\n");
        printf ("7) Quit\n");
        printf ("Enter option: ");    

        scanf ("%d", &choice);
       
           
        if (choice > 7){        // If user selects a number not on the menu report the error
            printf ("Non-existent Option\n");
        }    

        if (choice == 1){       // Taking user input into our above array (test)    
            printf ("enter numbers: ");
            int number = 0;
            int index = 0;
            int stop = -1;
            do{
                if (index == 19){
                    test[index] = stop;
                    printf ("number limit reached\n");
                                        masterindex = 19;
                    break;
                } else {  
                    scanf ("%d", &number );
                    test[index] = number;
                                        if (number == -1) {
                                                masterindex = index;
                                        }
                                        index++;
                }    
            } while (number != -1);
        
        
        } else if (choice == 2){        // Loop for dispalying array numbers and index
            int i;
            for (i = 0; i <= 19; i++){
                int at = test[i];

                if (at == -1){
                    printf ("# -1 @ array index %d\n", i);
                    break;
                } else {  
                    printf ("# %d @ array index %d\n", at,i);    
                }
            }
        } else if (choice == 3){ // Insert
            int nv, ai, in;
            printf ("enter new value: ");
            scanf ("%d", &nv);
            printf ("enter array index: ");
            scanf ("%d", &ai);
            for (in = masterindex; in >= ai; in--) {
                int nnv = test[in];
                int nai = in + 1;
                if (nai == 19) {
                    test[19] = -1;
            } else {
                test[nai] = nnv;
              }
                
            }
            masterindex++;
            if (masterindex > 19 ){
                masterindex = 19;                           
            }
            test[ai] = nv;   
        } else if (choice == 4){        // Append
            int nv, ai, in;
            printf ("enter new value: ");
            scanf ("%d", &nv);
            printf ("enter array index: ");
            scanf ("%d", &ai);
            ai++;
            for (in = masterindex; in >= ai; in--) {
                int nnv = test[in];
                int nai = in + 1;
                if (nai == 19) {
                    test[19] = -1;
            } else {
                test[nai] = nnv;
              }
                
            }
            masterindex++;
            if (masterindex > 19 ){
                masterindex = 19;                           
            }
            test[ai] = nv;   

        } else if (choice == 5){        // Choosing an array index and removing all numbers in the array after selected index
            int nv, ai, in;
            printf ("enter array index: ");
            scanf ("%d", &ai);
            printf ("# %d @ array index %d\n", test[ai],ai);
            for (in = ai + 1; in <= masterindex; in++){
                int nnv = test[in];
                int nai = in -1;
                test[nai] = nnv;
            }
            masterindex--;
            if (masterindex < 0) {
                masterindex = 0;
                test[0] = -1;
            }
        } else if (choice == 6){        // Clear the array by testing -1 at array index 0 & updating our master index 
            test[0] = -1;
            masterindex = 0;
            printf ("cleared\n");
        }         
    } while (choice != 7);      // Quit!
    return 0;
}

</code>

sln0 is coming along smoothly! 

====September 21, 2015====

Data structures is the most time consuming class i have ever taken in my college career. This is definitely stretching my time thin on almost every other class i am taking (thank god for HPC0 and Datacom). I was able to get sln0 done on time thanks to my some-what growing time management skills and help from Brian and Mohsin. This class has made me realize that i am an awful programmer with sub-par time management skills... Ahhh what a feeling! I am currently working on sln1 and it is definitely is much easier and less time consuming than the past two projects i have encountered. Thank god!!!

Here is my pseudo code from sln0 now that the deadline is up!

<code>
# Inserting into the list 1

tmp2 = start -> after       #tmp2 point tp the node after start
tmp2 -> after = mknode(6)   #making a new node after the node tmp is pointing to
tmp2 -> after -> after = tmp # the second node after tmp2 is now tmp
tmp = start
tmp2 = start
# Inserting into the list 2
tmp = start

if (tmp -> info  == 2){     # if the first node contains a two
        start = mknode(0)               # make a new node containing a zero that start points to
        start -> after = tmp    # now link that to tmp AKA our node containing a two
} else {
tmp2
    while (tmp != NULL){     #While tmp is not null
        if (tmp -> after -> info == 2){  # if the node after tmp contains a two
            tmp2 = tmp -> after     #set that node to tmp2
                        tmp -> after = mknode(0) #making new node that contains 0
                        tmp -> after -> after= tmp2 #linking them
        }
        tmp = tmp -> after #drives the loop
    }
}

# Display the list

tmp = start
while (tmp != NULL){       #while tmp is not null print the info contained in the node that tmp points to
        print tmp -> info
        tmp = tmp -> after }   #drives the loop

# Appending to the list 1
tmp = start   
tmp2 = start
if (tmp -> info  == 0){   #if the node contains a 0
    tmp = start -> after 

        start -> after = mknode (1) # making a new node containing a 1                                                                                                                                                               [0/186]
    start -> after -> after = tmp # linking them back
} else {
        tmp2
    while (tmp != NULL){  # while tmp is not null
        if (tmp -> info == 0){  # if the node tmp points to has a 0
                        tmp2 = tmp -> after # tmp2 is now the node after tmp
                        tmp -> after = mknode(1) # making a new node
                        tmp -> after -> after = tmp2 # linking them
                }
                tmp = tmp -> after
        }

#Copying the list
start2
tmp = start
while (tmp != NULL){
        start2 = tmp -> info
        tmp = tmp -> after
}

# Appending to the list 2
tmp = start
tmp2 = start                         #SEE APPEND 1
if (tmp -> info  == 8){
    tmp = start -> after 
    start -> after = mknode(12)
    start -> after -> after = tmp
} else {
    tmp2
    while (tmp != NULL){
        if (tmp -> info == 8){
            tmp2 = tmp -> after
            tmp -> after = mknode(12)
            tmp -> after -> after = tmp2
        }
        tmp = tmp -> after
    }

# Grabbing from list #1
tmp = start
tmp2 = start
if (tmp -> info  == 6){
    start = start -> after
} else {
tmp2
tmp3
    while (tmp != NULL){
        if (tmp -> after -> info == 6){
            tmp3 = tmp -> after 
            tmp2 = tmp -> after -> after
            tmp -> tmp2
        }
        tmp = tmp -> after
    }
}
# Grabbing from list #2
tmp = start2
tmp2 = start2
if (tmp -> info  == 0){
    start2 = start2 -> after
} else {
tmp2
tmp3
    while (tmp != NULL){
        if (tmp -> after -> info == 0){
            tmp3 = tmp -> after 
            tmp2 = tmp -> after -> after
            tmp -> tmp2
        }
        tmp = tmp -> after
    }
}


</code>

====September 28, 2015====
<code>
CFLAGS = -fPIC -Wall
INC = -I ../../inc
AR = ar
CC = gcc
SRC = $(shell /bin/ls -1 *.c 2>/dev/null)
OBJ = $(SRC:.c=.o)
LIB = $(shell /bin/pwd | /bin/sed 's/^.*\///')
NAME = $(shell echo "$(LIB)" | /usr/bin/tr '[:lower:]' '[:upper:]')
all: intro $(SRC) $(OBJ) lib

intro:
ifneq ($(MAKECMDGOALS),debug)
        @printf "Building the \033[1;36m$(NAME)\033[0m library\n"
        @printf "=======================================\n"
endif

debug: CFLAGS += -DDEBUG -g
debug: DEBUG = debug
debug: $(SRC) $(OBJ) lib

.c.o:
ifneq ($(MAKECMDGOALS),debug)
        @printf "[\033[0;33mCC\033[0m]   %-20s ... " "$<"
        @$(CC) $(CFLAGS) $(INC) -c $< 2>> ../../errors && echo "\033[0;32mOK\033[0m" || echo "\033[0;31mFAIL\033[0m"
else
        $(CC)  $(CFLAGS) $(INC) -c $<
endif

lib:
ifneq ($(MAKECMDGOALS),debug)
        @printf "       %-20s ... " "lib$(LIB).{a,so}"
        @$(AR) rcs ../../lib/lib$(LIB).a $(OBJ) 2>> ../../errors && $(CC) -shared -o ../../lib/lib$(LIB).so -Wl,--whole-archive ../../lib/lib$(LIB).a -Wl,--no-whole-archive && echo "\033[1;32mSUCCESS\033[0m" || echo "\033[1;31mFAIL\033[0m"
        @echo
else
        $(AR)  rcs ../../lib/lib$(LIB).a $(OBJ)
        $(CC) -shared -o ../../lib/lib$(LIB).so -Wl,--whole-archive ../../lib/lib$(LIB).a -Wl,--no-whole-archive
endif

clean:
        @rm -f .*.sw[op] *.save* *~ *.o $(OBJ) core ../../errors

</code>

====October 5, 2015====
#include "list.h"
<code c>
//////////////////////////////////////////////////////////////////////
//
//   insert() - add a new node to the given list before the node
//              at the indicated place. insert() needs to manage
//              the necessary connections pointers) to maintain list
//              integrity, along with ensuring the start and end
//              indicators of the list remain relevant and up-to-date.
//
//    behavior: on a NULL list- allocate a list and proceed
//              on a NULL newNode- return list as is
//
//        note: you are expected to make use of the getpos() and
//              setpos() functions to aid you in accomplishing this
//              task. Don't needlessly reinvent the wheel.
//
//              as with the other functions, you may use no more
//              than one return() statement per function.
//
List *insert(List *myList, Node *place, Node *newNode)
{
        if(myList == NULL) { //check if list is NULL
                myList = mklist(); //make new list
        }
        if(newNode != NULL) { //checks if newNode is not NULL
                if(myList -> first == NULL || myList -> last == NULL) { //checks beginning and end
                        myList -> first = newNode;
                        myList -> last = newNode;
                } else {
                        int pos = getpos(myList, place);
                        if(pos == 0) {
                                myList -> first = newNode;
                        } else {
                                Node *before = setpos(myList, pos - 1); //set pos
                                before -> after = newNode;
                        }
                        newNode -> after = place;
                }
        }
        //returns
        return(myList);
}

// Author: Dan Shadeck
// 09/29/2015
// Data Structures
</code>

<code c>
#include <stdio.h>
#include "list.h"

//////////////////////////////////////////////////////////////////////
//
// displayf() - display the list in a specified orientation, also
//              with or without positional values (as indicated
//              by the mode parameter).
//
//       modes: 0 display the list forward, no positional values
//              1 display the list forward, with positional values
//     
//        note: positional values are indexed starting from 0
//     
//    behavior: on a NULL list, output "NULL"
//              on an EMPTY list, output "-> NULL"
//              on error (invalid mode): MOD by 2 and do the result
//                 (or the logical equivalent)
//
//      format: output is to be on a single line, with node values
//              space-padded. and separated by "->" sequences, flush
//              against the left margin, of the forms:
//
// for forward:   val0 -> val1 -> val2 -> ... -> valN-1 -> valN -> NULL
//
//              or, if being displayed with node positions:
//
// for forward: [0] val0 -> [1] val1 -> ... -> [N-1] valN-1 -> [N] valN -> NULL
//
//        note: ALL output ends with a newline character
//
void displayf(List *myList, int mode)
{
        if(myList == NULL) {
                printf("NULL\n");
        } else if (mode==0){
                Node *tmp = myList -> first;
                char ran = 'f';
                while (tmp != NULL){
                        ran = 't';
                        printf ("%hhd -> ", tmp -> info);
                        tmp = tmp -> after; // getting the next value
                }
                if(ran == 't') {
                        printf("NULL\n");
                } else {
                        printf("-> NULL\n");
                }
        } else if (mode==1){
                Node *tmp = myList -> first;
                int count = 0;
                char ran = 'f';
                while (tmp != NULL){
                        ran = 't';
                        printf ("[%d] %hhd -> ", count, tmp -> info);
                        tmp = tmp -> after; //getting the next value
                        count++;        //incr count to give us node position 
                }
                if(ran == 't') {
                        printf("NULL\n");
                } else {
                        printf("-> NULL\n");
                }
        }
}

// this is displaying the list with or with out position values

// Author: Dan Shadeck
// 09/29/2015
// Data Structures

</code>

<code c>
//////////////////////////////////////////////////////////////////////
//
// getpos() - a list library utility function to identify the actual
//            position of a given node in an indicated list.
//
//      note: Indexing of the list starts from 0
//
//  behavior: on error (NULL list or given node), return negative
//            value (-1), on out-of-bounds condition, return -2
//
//            you are to have only ONE return statement for this
//            entire function. Change the existing one as needed.
//
int getpos(List *myList, Node *given)
{
    int count = 0;
        char broke = 'f';
        if(myList == NULL || given == NULL) { //checks if both list and given are NULL
                count = -1;
        } else {
                Node *tmp = myList -> first;
        while (tmp != NULL){
                if (tmp == given){
                broke = 't';
                break;
                }
                tmp = tmp -> after; //getting the next value
                count++;    //incr count to give us node position 
        }
        }
    if(broke == 'f' && count != -1) {// checks if loop broke
                count = -2;
        }
        return(count);
}

//////////////////////////////////////////////////////////////////////
//
// setpos() - a list library utility function to set a node pointer
//            to the node at the indicated position of a list.
//
//      note: Indexing of the list starts from 0
//
//  behavior: on error (NULL list or negative/out-of-bounds pos),
//            return NULL.
//
//            you are to have only ONE return statement for this
//            entire function. Change the existing one as needed.
//
Node *setpos(List *myList, int pos)
{
        //returning node variable
        Node *node = NULL;
        if(myList != NULL && pos >= 0) { //checking if list is null and pos index
                Node *tmp = myList -> first;
                int counter = 0;
                while(tmp != NULL) {//while loop; checks tmp not NULL
                        if(counter == pos) {
                                node = tmp;
                                break;
                        }
                        tmp = tmp -> after;
                        counter++;
                }
        }
        //returns
        return(node);
}

// Author: Dan Shadeck
// 09/29/2015
// Data Structures

</code>

<code c>
#include "list.h"

//////////////////////////////////////////////////////////////////////
//
// mklist() - a list library function to allocate and initialize a 
//            new list.
//
//  behavior: on error, return NULL.
//
//      note: you are to have only ONE return statement for this
//            entire function. Change the existing one as needed.
//
List *mklist(void)
{
        List *newlist = (List *) malloc(sizeof(List)); //allocating mem 

        return(newlist);  

}

// extra comment just to be clear that this is a list library function to allocate and initialize a new list

// Author: Daniel Shadeck
// 9/29/2015
// Data Structures

</code>
=====Data Communications=====

====August 31, 2015====

I was sad to miss the first day of data communications as this class is definitely the one that interests me the most. We looked at what the best way to network the new classroom would be and decided that having a switch in the campus network closet would the best idea. We set up out switch with the proper IP address, subnet mask, and gateway to get it ready to deploy! 


====September 07, 2015====

I am excited to see Matt is bringing back the sleep data project. I feel that this a valuable learning tool to understand basic hardware hacking. We went over the project page and should get a start tomorrow! 

====September 14, 2015====

Here is some code we have created in class to help sift through the sleep data! 

great progress.

<code c>
#include <stdio.h>
#include <stdlib.h>

int main()
{
        FILE *fptr;
        unsigned char byte;
        unsigned char chksum = 0;
        unsigned char chksumchk = 0;
        unsigned short int msglen = 0;
        unsigned short int imsglen = 0;
        unsigned char time_sec = 0;
        unsigned short int sub_sec = 0;
        unsigned char seq_num = 0;
        unsigned char dtype = 0;
        unsigned char *dblock;
        char pktflag = -1;
        int  i       = 0;

        fptr = fopen ("sleep.data", "r");

        while ((byte = fgetc(fptr)) != EOF)
        {
                if (pktflag  == -1) // not currently processing a data packet
                {
                        if (byte == 0x41)
                        {
                                pktflag = 0;
                        }
                }
                else if (pktflag == 0) // check for 2nd byte of packet
                {
                        if (byte == 0x34)
                        {
                                pktflag = 1;
                        }
                        else
                                pktflag = -1;
                }
                else if (pktflag == 1) // store checksum byte
                {
                        pktflag = 2;
                        chksum  = byte;
                }
                else if (pktflag == 2) // store msglen bytes
                {
                        pktflag = 3;
                        msglen  = byte;
                        byte    = fgetc(fptr);
                        msglen  = msglen | (unsigned short int)byte << 8;
                }
                else if (pktflag == 3) // store inverse msglen bytes
                {
                        imsglen = byte;
                        byte    = fgetc(fptr);
                        imsglen = imsglen | (unsigned short int)byte << 8;
                        if ((msglen & imsglen) == 0)
                                pktflag = 4;
                        else
                                pktflag = -1;
                }
                else if (pktflag == 4)
                {
                        time_sec = byte;
                        pktflag = 5;
                }
                else if (pktflag == 5)
                {
                        pktflag = 6;
                        sub_sec = byte;
                        byte    = fgetc(fptr);
                        sub_sec = sub_sec | (unsigned short int)byte << 8;
                }
                else if (pktflag == 6)
                 {
                        seq_num = byte;
                        pktflag = 7;
                }
                else if (pktflag == 7)
                {
                        dtype   = byte;
                        pktflag = 8;
                        chksumchk = dtype;

                        dblock  = (unsigned char *) malloc (sizeof(char) * (msglen - 1));
                        for(i=0; i<(msglen-1); i++)
                        {
                                (*(dblock+i)) = fgetc(fptr);
                                chksumchk   = chksumchk + (*dblock+i);
                        }

                        if (chksum == chksumchk) // we have a valid packet
                        {
                                fprintf(stdout, "chksum: %.2x msglen: %.4x time_sec: %.2x dtype: %.2x dblock: ", chksum, msglen, time_sec, dtype);
                                for(i=0; i<(msglen-1); i++)
                                        fprintf(stdout, "%.2x ", (*dblock+i));
                                fprintf(stdout, "\n");
                        }
                }

//              fprintf(stdout, "We read: %.2hhX\n", byte);
        }

        fclose(fptr);

        return(0);
}

</code>

====September 21, 2015====

We made some really cool additions to the code today! We now are able to graphicaly track out signal strength packets with a nifty graph thanks to the gd library. While our graph is not impressive it definitely is a great start. Matt showed us a graph from his personal code and i was more than impressed. To think that the library we are using can produce such impressive results was great encouragement to keep on trucking along! Here is what he have as of today.

<code c>

                // gcc -o read read.c -lgd
// http://www.boutell.com/gd/manual2.0.33.html
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <gd.h>

int main()
{
        FILE *fptr;
        gdImagePtr img;
        gdPoint points[2000];
        unsigned char byte;
        unsigned char chksum = 0;
        unsigned char chksumchk = 0;
        unsigned short int msglen = 0;
        unsigned short int imsglen = 0;
        unsigned char time_sec = 0;
        unsigned short int sub_sec = 0;
        unsigned char seq_num = 0;
        unsigned char dtype = 0;
        unsigned char *dblock;
        char pktflag = -1;
        int  i       = 0;
        int  j       = 0;
        int  num     = 0;
        int  invalid = 0;
        int  valid = 0;
        int  total = 0;
        time_t mytime = 0;
        unsigned int  tmp   = 0;
        unsigned int color[3];

        struct tm *pkt_time;

        fptr = fopen ("sleep.data", "r");

        img = gdImageCreateTrueColor(2000, 50);

        byte = fgetc(fptr);
        while (!feof(fptr))
        {
                if (pktflag  == -1) // not currently processing a data packet
                {
                        if (byte == 0x41)
                        {
                                pktflag = 0;
                        }
                }
                else if (pktflag == 0) // check for 2nd byte of packet
                {
                        if (byte == 0x34)
                        {
                                pktflag = 1;
                        }
                        else
                                pktflag = -1;
                }
                else if (pktflag == 1) // store checksum byte
                {
                        pktflag = 2;
                        chksum  = byte;
                }
                else if (pktflag == 2) // store msglen bytes
                {
         pktflag=3;                                                                                                                                                                                                [74/432]
                        msglen  = byte;
                        byte    = fgetc(fptr);
                        msglen  = msglen | (unsigned short int)byte << 8;
                }
                else if (pktflag == 3) // store inverse msglen bytes
                {
                        imsglen = byte;
                        byte    = fgetc(fptr);
                        imsglen = imsglen | (unsigned short int)byte << 8;
                        if ((msglen & imsglen) == 0)
                                pktflag = 4;
                        else
                                pktflag = -1;
                }
                else if (pktflag == 4)
                {
                        time_sec = byte;
                        pktflag = 5;
                }
                else if (pktflag == 5)
                {
                        pktflag = 6;
                        sub_sec = byte;
                        byte    = fgetc(fptr);
                        sub_sec = sub_sec | (unsigned short int)byte << 8;
                }
                else if (pktflag == 6)
                {
                        seq_num = byte;
                        pktflag = 7;
                }
                else if (pktflag == 7)
                {
                        dtype      = byte;
                        chksumchk  = dtype;

                        dblock     = (unsigned char *) malloc (sizeof(char) * (msglen - 1));
                        for(i=0; i<  (msglen-1); i++)
                        {
                                (*(dblock+i))  = fgetc(fptr);
                                chksumchk      = chksumchk + (*(dblock+i));
                        }

                        if (chksum == chksumchk) // we have a valid packet
                        {
                                fprintf(stdout, "[%.4d] chksum: %.2x msglen: %.4x time_sec: %.2x dtype: ", total, chksum, msglen, time_sec);
                                switch (dtype)
                                {
                                        case 0x03:
                                                fprintf(stdout, "version   ");
                                                tmp = (*(dblock+0));
                                                tmp = tmp | (unsigned int)(*(dblock+1)) << 8;
                                                tmp = tmp | (unsigned int)(*(dblock+2)) << 16;
                                                tmp = tmp | (unsigned int)(*(dblock+3)) << 24;
                                                fprintf(stdout, "%u", tmp);
                                                break;

                                        case 0x80:
                                                fprintf(stdout, "brainwave ");
                                                break;

                                        case 0x84:
                                                fprintf(stdout, "signal    %d/30", (*dblock));
                                                points[num].x = num;
                                                points[num].y = ((*dblock) - 30) * -1;
                                                num++;
                                                break;

                                        case 0x8a:
                                                fprintf(stdout, "timestamp ");
                                                tmp = (*(dblock+0));
                                                tmp = tmp | (unsigned int)(*(dblock+1)) << 8;
                                                tmp = tmp | (unsigned int)(*(dblock+2)) << 16;
                                                tmp = tmp | (unsigned int)(*(dblock+3)) << 24;

                                                tmp = tmp | (unsigned int)(*(dblock+3)) << 24;
                                                mytime = tmp;
                                                pkt_time = localtime(&mytime);
                                                fprintf(stdout, "%.4d/%.2d/%.2d %.2d:%.2d:%.2d",
                                                                                     pkt_time -> tm_year + 1900,
                                                                                                                         pkt_time -> tm_mon + 1,
                                                                                     pkt_time -> tm_mday,
                                                                                                                         pkt_time -> tm_hour,
                                                                                                                         pkt_time -> tm_min,
                                                                                                                         pkt_time -> tm_sec);
                                                break;

                                        default:
                                                fprintf(stdout, "%-9.2x ", dtype);
                                                fprintf(stdout, "\n\t data: ");
                                                j = -1;
                                                for(i=(msglen-2); i>=0; i--)
                                                {
                                                        if (j == 15)
                                                        {
                                                                fprintf(stdout, "\n\t       ");
                                                                j = 0;
                                                        }
                                                        else
                                                                j++;

                                                        fprintf(stdout, "%.2x ", (*(dblock+i)));
                                                }
                                                break;
                                }

                                fprintf(stdout, "\n");
                                valid++;
                        }
                        else
                        {
                                fprintf(stdout, "ERROR! Checksums do not match! [%.2hhx:%.2hhx]\n", chksum, chksumchk);
                                invalid++;
                        }

                        total++;
                        pktflag  = -1;
                }

                byte = fgetc(fptr);
//              fprintf(stdout, "We read: %.2hhX\n", byte);
        }

        fprintf(stdout, "Valid: %d\tInvalid: %d\tTotal: %d\n", valid, invalid, total);
        fclose(fptr);

        #define BLACK 0
        #define WHITE 1
        #define RED   2

        color[BLACK] = gdImageColorAllocate(img, 0, 0, 0);
        color[WHITE] = gdImageColorAllocate(img, 255, 255, 255);
        color[RED] = gdImageColorAllocate(img, 255, 0, 0);

        gdImageFilledRectangle(img, 0, 0, num+19, 49, color[WHITE]);
        gdImageRectangle(img, 5, 5, num+14, 44, color[BLACK]);

        for(i = 0; i < num; i++)
        {
                gdImageLine(img, points[i].x+10, points[i].y+10, points[i].x+10, points[i].y+10, color[RED]);
        }

        fptr = fopen("chart.png", "wb");
        gdImagePngEx(img, fptr, -1);
        fclose(fptr);
        gdImageDestroy(img);

        return(0);
}

</code>

====September 28, 2015====
Brian and i have been working on using gd to create a better graph for the signal strength info we collect from the packets. here is what we have so far.

<code c>

                // gcc -o read read.c -lgd
// http://www.boutell.com/gd/manual2.0.33.html
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <gd.h>

int main()
{
        FILE *fptr;
        gdImagePtr img;
        gdPoint points[2000];
        unsigned char byte;
        unsigned char chksum = 0;
        unsigned char chksumchk = 0;
        unsigned short int msglen = 0;
        unsigned short int imsglen = 0;
        unsigned char time_sec = 0;
        unsigned short int sub_sec = 0;
        unsigned char seq_num = 0;
        unsigned char dtype = 0;
        unsigned char *dblock;
        char pktflag = -1;
        int  i       = 0;
        int  j       = 0;
        int  num     = 0;
        int  invalid = 0;
        int  valid = 0;
        int  total = 0;
        time_t mytime = 0;
        unsigned int  tmp   = 0;
        unsigned int color[3];

        struct tm *pkt_time;

        fptr = fopen ("sleep.data", "r");

        img = gdImageCreateTrueColor(2000, 50);

        byte = fgetc(fptr);
        while (!feof(fptr))
        {
                if (pktflag  == -1) // not currently processing a data packet
                {
                        if (byte == 0x41)
                        {
                                pktflag = 0;
                        }
                }
                else if (pktflag == 0) // check for 2nd byte of packet
                {
                        if (byte == 0x34)
                        {
                                pktflag = 1;
                        }
                        else
                                pktflag = -1;
                }
                else if (pktflag == 1) // store checksum byte
                {
                        pktflag = 2;
                        chksum  = byte;
                }
                else if (pktflag == 2) // store msglen bytes
                {
         pktflag=3;                                                                                                                                                                                                [74/432]
                        msglen  = byte;
                        byte    = fgetc(fptr);
                        msglen  = msglen | (unsigned short int)byte << 8;
                }
                else if (pktflag == 3) // store inverse msglen bytes
                {
                        imsglen = byte;
                        byte    = fgetc(fptr);
                        imsglen = imsglen | (unsigned short int)byte << 8;
                        if ((msglen & imsglen) == 0)
                                pktflag = 4;
                        else
                                pktflag = -1;
                }
                else if (pktflag == 4)
                {
                        time_sec = byte;
                        pktflag = 5;
                }
                else if (pktflag == 5)
                {
                        pktflag = 6;
                        sub_sec = byte;
                        byte    = fgetc(fptr);
                        sub_sec = sub_sec | (unsigned short int)byte << 8;
                }
                else if (pktflag == 6)
                {
                        seq_num = byte;
                        pktflag = 7;
                }
                else if (pktflag == 7)
                {
                        dtype      = byte;
                        chksumchk  = dtype;

                        dblock     = (unsigned char *) malloc (sizeof(char) * (msglen - 1));
                        for(i=0; i<  (msglen-1); i++)
                        {
                                (*(dblock+i))  = fgetc(fptr);
                                chksumchk      = chksumchk + (*(dblock+i));
                        }

                        if (chksum == chksumchk) // we have a valid packet
                        {
                                fprintf(stdout, "[%.4d] chksum: %.2x msglen: %.4x time_sec: %.2x dtype: ", total, chksum, msglen, time_sec);
                                switch (dtype)
                                {
                                        case 0x03:
                                                fprintf(stdout, "version   ");
                                                tmp = (*(dblock+0));
                                                tmp = tmp | (unsigned int)(*(dblock+1)) << 8;
                                                tmp = tmp | (unsigned int)(*(dblock+2)) << 16;
                                                tmp = tmp | (unsigned int)(*(dblock+3)) << 24;
                                                fprintf(stdout, "%u", tmp);
                                                break;

                                        case 0x80:
                                                fprintf(stdout, "brainwave ");
                                                break;

                                        case 0x84:
                                                fprintf(stdout, "signal    %d/30", (*dblock));
                                                points[num].x = num;
                                                points[num].y = ((*dblock) - 30) * -1;
                                                num++;
                                                break;

                                        case 0x8a:
                                                fprintf(stdout, "timestamp ");
                                                tmp = (*(dblock+0));
                                                tmp = tmp | (unsigned int)(*(dblock+1)) << 8;
                                                tmp = tmp | (unsigned int)(*(dblock+2)) << 16;
                                                tmp = tmp | (unsigned int)(*(dblock+3)) << 24;

                                                tmp = tmp | (unsigned int)(*(dblock+3)) << 24;
                                                mytime = tmp;
                                                pkt_time = localtime(&mytime);
                                                fprintf(stdout, "%.4d/%.2d/%.2d %.2d:%.2d:%.2d",
                                                                                     pkt_time -> tm_year + 1900,
                                                                                                                         pkt_time -> tm_mon + 1,
                                                                                     pkt_time -> tm_mday,
                                                                                                                         pkt_time -> tm_hour,
                                                                                                                         pkt_time -> tm_min,
                                                                                                                         pkt_time -> tm_sec);
                                                break;

                                        default:
                                                fprintf(stdout, "%-9.2x ", dtype);
                                                fprintf(stdout, "\n\t data: ");
                                                j = -1;
                                                for(i=(msglen-2); i>=0; i--)
                                                {
                                                        if (j == 15)
                                                        {
                                                                fprintf(stdout, "\n\t       ");
                                                                j = 0;
                                                        }
                                                        else
                                                                j++;

                                                        fprintf(stdout, "%.2x ", (*(dblock+i)));
                                                }
                                                break;
                                }

                                fprintf(stdout, "\n");
                                valid++;
                        }
                        else
                        {
                                fprintf(stdout, "ERROR! Checksums do not match! [%.2hhx:%.2hhx]\n", chksum, chksumchk);
                                invalid++;
                        }

                        total++;
                        pktflag  = -1;
                }

                byte = fgetc(fptr);
//              fprintf(stdout, "We read: %.2hhX\n", byte);
        }

        fprintf(stdout, "Valid: %d\tInvalid: %d\tTotal: %d\n", valid, invalid, total);
        fclose(fptr);

 #define BLACK 0
    #define WHITE 1
    #define RED   2

    color[BLACK] = gdImageColorAllocate(img, 0, 0, 0);
    color[WHITE] = gdImageColorAllocate(img, 255, 255, 255);
    color[RED] = gdImageColorAllocate(img, 0, 255, 0);

    gdImageFilledRectangle(img,0, 0, num+1999, 499, color[BLACK]);
    gdImageRectangle(img, 50, 5, num+1994, 444, color[WHITE]);

    for(i = 0; i < num; i++)
    {
       gdImageLine(img, points[i].x+50, points[i].y+400, points[i].x+50, points[i].y+410, color[RED])    ;
    }

    fptr = fopen("chart.png", "wb");
    gdImagePngEx(img, fptr, -1);
    fclose(fptr);
    gdImageDestroy(img);

    return(0);                                                                                                                                                                                               
}

</code>

====October 5, 2015====

Lets hope that today we have a break through on the chart.
Lab46 Wiki

User Tools

Site Tools

Page Tools
