On branch pseudocode

Changes to be committed:
	modified:   main.go
		Due tomorrow, only a few hours found for this project, so
		the choice to flesh out ideas in pseudocode was made.

main.go

@@ -1,7 +1,9 @@
 package main
 
 import (
-"./timer"
+"reflect"
+//"./timer"
+"time"
 "fmt"
 "strings"
 "regexp"
@@ -10,7 +12,10 @@ import (
 )
 
 
+var tcp_data string = read_tcp_file("/proc/net/tcp")
+
 func main() {
+	var loops int	= 0
 	// How to split on space-delimited fields, then colon-delimited fields?
 	// How to turn this byte into a string?
 
@@ -18,8 +23,28 @@ func main() {
 	// and then converted byte by byte (2 char at a time)
 	//fmt.Println(convert_address(reverse_string(reverse_bytes("0100007F"))))
 
-	timer.New()
+	for _ = range time.Tick(10 * time.Second) {
-	tcp_rows(read_tcp_file("/proc/net/tcp"))
+		fmt.Println("Waiting 10 seconds...")
+		for num, row := range get_tcp_rows(tcp_data) {
+			row_type	:= reflect.TypeOf(row)
+			fmt.Println(num, " ", row_type)
+		}
+	// if loops modulo 6 (1min) then
+	// 	for address in address_list do
+	//		if (grep address address_list | wc -l >=3) then
+	//			This is a port scan!
+	//		fi
+	//	done
+	// elseif (wc -l old_tcp_file > wc -l tcp_file) then
+	//	for i in (wc -l tcp_file - wc -l old_tcp_flle) do
+	//		print New Connection! reverse_strng(reverse_bytes(tcp_file[i])) // This oversimplifies row value selection for the sake
+	//										// of pseudocode
+	//	done
+	// else
+	//	"No new connections. Waiting another 10 seconds..."
+	// fi
+		loops++
+	}
 }
 
 func check(e error) {
@@ -28,17 +53,21 @@ func check(e error) {
     }
 }
 
-func tcp_rows(connections_file string) {
+// Aiming for an array of [string]string maps
-	regexpression	:= regexp.MustCompile(`[^a-zA-Z0-9:\r\n\t\v]+`)
+// Am I looking for a map[string]interface here?
-	tcp_lines	:= strings.Split(connections_file, "\n")
+func get_tcp_rows(connections_file string) []string {
+	tcp_lines		:= strings.Split(connections_file, "\n")
+	regexpression		:= regexp.MustCompile(`[\r\n\t\f\v]+`)
+	tcp_columns		:= regexpression.Split(tcp_lines[0], -1)
+	var tcp_values map[string]string
 
-	for _, line	:= range tcp_lines {
+	for i, line	:= range tcp_lines[1:] {
-		trim_line	:= strings.TrimSpace(line)
+		trim_line			:= strings.TrimSpace(line)
-		values		:= regexpression.ReplaceAllString(trim_line, ",")
+		values				:= regexpression.Split(trim_line, -1)
-// Debug
+		column				:= tcp_columns[i]
-//		fmt.Println("New Line ==========")
+		tcp_values[column]		= values
-		fmt.Println(values)
 	}
+	return tcp_values
 }
 
 // Take a string, create a rune slice, and use a loop to reverse it character-wise.

timer/timer.go

@@ -6,16 +6,30 @@ import (
 //"reflect"
 )
 
-func New() {
+func New(duration_int int, unit string) *time.Timer {
 
-	timer_10s	:= time.NewTimer(10 * time.Second)
+	start		:= time.NewTimer(0)
+	duration	:= time.Duration(duration_int)
+//	fmt.Println(reflect.TypeOf(duration))
+//	timer_10s	:= time.NewTimer(10 * time.Second)
 //	timer_1m	:= time.NewTimer(1 * time.Minute)
-	fmt.Println("Waiting 10 seconds...")
+	fmt.Println("Duration: ", duration_int, "Unit: ", unit, ".")
-	<-timer_10s.C
+	if unit == "Second" {
-
+		start	= time.NewTimer(duration * time.Second)
-
+	} else if unit == "Minute" {
-
+		start	= time.NewTimer(duration * time.Minute)
+	} else {
+		fmt.Println("Unit not recognized.")
+	}
+	fmt.Println("Waiting ", duration_int, " ", unit, ".")
+	if start.Stop() {
+	<-start.C
+	fmt.Println("Done waiting ", duration_int, " ", unit, "!")
+	}
+	return start
 //	for elapsed < ten_seconds {
 //}
 //	for 
 }
+
+func Reset