Exemple #1
0
func Ping(pi pingInfo) pingResponse {
	pr := pingResponse{}
	pr.err = nil

	conn, err := icmp.ListenPacket("udp4", configuration.GetDeviceIP())

	if err != nil {
		msg := "Could not create a packet endpoint on ip: " + configuration.GetDeviceIP()
		fmt.Println(err)
		logger.WriteString(msg)
		pr.err = errors.New(msg)
		return pr
	}

	defer conn.Close()

	logger.WriteString("Starting test number " + strconv.Itoa(sequence))

	testNetwork(&pr, pi, conn)
	testInternet(&pr, pi, conn)
	// testDNS(&pr, pi, conn)

	logger.WriteString("Finished test number " + strconv.Itoa(sequence))

	sequence++
	return pr
}
Exemple #2
0
// This checks if we can convert an URL to an IP
func testDNS(pr *pingResponse, pi pingInfo, conn *icmp.PacketConn) {
	start := time.Now()
	msg := createMessage()

	msg_bytes, err := msg.Marshal(nil)
	if err != nil {
		emsg := "Could not marshal the message to []byte."
		logger.WriteString(emsg)
		pr.err = errors.New(emsg)
		return
	}

	ip, _ := net.LookupHost(pi.externalurl)

	if _, err := conn.WriteTo(msg_bytes, &net.UDPAddr{IP: net.ParseIP(ip[0]), Zone: "en0"}); err != nil {
		emsg := "Could not write to the internal ip address: " + ip[0]
		logger.WriteString(emsg)
		pr.external_url = false
		pr.err = errors.New(emsg)
		return
	}

	pr.external_url = true

	response := make([]byte, 1500)
	count, peer, err := conn.ReadFrom(response)
	if err != nil {
		emsg := "Could not read the response."
		logger.WriteString(emsg)
		pr.external_url = false
		pr.err = errors.New(emsg)
		return
	}

	_, err = icmp.ParseMessage(protocolICMP, response[:count])
	if err != nil {
		emsg := "Could not parse the message received."
		logger.WriteString(emsg)
		pr.external_url = false
		pr.err = errors.New(emsg)
		return
	}

	logger.WriteString("Response " + strconv.Itoa(sequence) + " received from " + peer.String() +
		" after " + time.Now().Sub(start).String())
}
// CheckLogin - Validates a login attempt or redirects the user to
// an error page which redirects them to "Root"
func CheckLogin(w http.ResponseWriter, r *http.Request) {
	uname := r.FormValue("username")
	pword := r.FormValue("password")

	// Authenticate user credentials
	// Hash password
	hash := sha256.Sum256([]byte(pword))
	authenticated := auth.CheckCredentials(uname, hash)

	if authenticated == true {
		logger.WriteString("User \"" + uname + "\" authenticated successfully.")
		auth.SetSessionID(w)
		http.Redirect(w, r, "/dashboard", http.StatusFound)
	} else {
		logger.WriteString("User \"" + uname + "\" did not authenticate successfully.")
		servePageStatic(w, r, loc+"/html/error.html")
	}
}
func RunTest(pi pingInfo, runlen int) {
	tl := map[string]int{
		"internal": 0,
		"extip":    0,
		"exturl":   0,
		"total":    0,
	}

	lp := time.Now()
	end := time.Now().Add(time.Duration(runlen) * time.Hour)

	logger.WriteString("Starting the test...")

	for time.Now().Before(end) {
		delay, _ := strconv.Atoi(pi.pingDelay)
		if time.Now().After(lp.Add(time.Duration(delay) * time.Second)) {
			pr := Ping(pi)
			lp = time.Now()

			if pr.internal {
				tl["internal"]++
			}
			if pr.external_ip {
				tl["extip"]++
			}
			// if pr.external_url {
			// 	tl["exturl"]++
			// }
			tl["total"]++

			timeline := "Internal Ping Success Count: " + strconv.Itoa(tl["internal"]) + "/" + strconv.Itoa(tl["total"]) +
				"\nExternal IP Ping Success Count: " + strconv.Itoa(tl["extip"]) + "/" + strconv.Itoa(tl["total"]) //+
			// "\nExternal URL Ping Success Count: " + strconv.Itoa(tl["exturl"]) + "/" + strconv.Itoa(tl["total"])

			reporter.SetTimeline(timeline)
		}
		// speedtest -- later
	}

	logger.WriteString("The test has been completed.")
}
Exemple #5
0
func init() {
	cl := loc + "/.cookies"
	logger.WriteString("Removing the existing .cookies file")
	os.Remove(cl)

	// this is here because apparently auth's init() is called before this one is
	if _, err := os.Stat(cl); os.IsNotExist(err) {
		logger.WriteString("Creating a new .cookies file.")
		file, e := os.Create(cl)
		if e != nil {
			logger.WriteString("There was an error creating the .cookies file.")
		}
		file.Close()
	}

	if _, err := os.Stat(loc + "/.password"); os.IsNotExist(err) {
		logger.WriteString("The .password file does not exist. Creating a new .password file.")
		file, e := os.Create(loc + "/.password")
		if e != nil {
			logger.WriteString("There was an error creating the .password file.")
		}
		file.Close()
	}

	logger.WriteString("Setting the port number to " + configuration.GetPortNumber())
	portNumber = ":" + configuration.GetPortNumber()
}
// SaveTest - The test has had it's "test specific settings "
func SaveTest(w http.ResponseWriter, r *http.Request) {
	valid := auth.CheckSessionID(r)

	if valid {
		if r.FormValue("runlength") == "" || r.FormValue("location") == "" {
			errMsg = "You need to enter a run length and a location!"
			http.Redirect(w, r, "/dashboard/start_test", http.StatusFound)
		} else {
			td := tools.TestData{}
			td.Runlen = r.FormValue("runlength")
			td.Ext_ip = r.FormValue("externalIP")
			td.Ext_url = r.FormValue("externalURL")
			td.Location = r.FormValue("location")
			td.Ping_delay = r.FormValue("pingdelay")
			td.Speedtest_delay = r.FormValue("speedtestedelay")
			td.Speedtestfile = r.FormValue("stestfileloc")

			pi, err := tools.SetupTest(td)

			if err != nil {
				errMsg = "No ip associated with the key could be found."
				http.Redirect(w, r, "/dashboard/start_test", http.StatusFound)
			}

			reporter.SetStartTime(time.Now().Format("Jan 02, 2006 - 15:04"))
			reporter.SetLocation(td.Location)

			runlen, _ := strconv.Atoi(td.Runlen)
			logger.WriteString("Running test for: " + td.Runlen)
			// go tools.RunTest(pi, runlen)
			tools.RunTest(pi, runlen)
			http.Redirect(w, r, "/dashboard/reports", http.StatusFound)
		}
	} else {
		http.Redirect(w, r, "/", http.StatusFound)
	}
}