/*
* Import the collections directory and Import the files as collection lists.
*/
func (t *Developer) importcollections(response http.ResponseWriter, request *http.Request) {
filepath.Walk("import/collections/", func(path string, info os.FileInfo, err error) error {
if !info.IsDir() {
file, err := os.Open(path)
defer file.Close()
scanner := bufio.NewScanner(file)
collectionHelper, err := datastore.GetFilterCollectionHelper()
if err != nil {
log.Println("Error: Getting Helper Error:" + err.Error())
http.Error(response, err.Error(), 500)
return err
}
collection, err := collectionHelper.GetFilterCollection(info.Name())
if err != nil {
log.Println("Error: Getting Collection:" + err.Error())
http.Error(response, err.Error(), 500)
return err
}
collection.Name = info.Name()
if collection.Domains == nil {
collection.Domains = make([]string, 0, 0)
for scanner.Scan() {
collection.Domains = append(collection.Domains, scanner.Text())
}
} else {
for scanner.Scan() {
for _, existingDomain := range collection.Domains {
if existingDomain == scanner.Text() {
//Yeah lets goto! Aka Break 2
goto Break2
}
}
collection.Domains = append(collection.Domains, scanner.Text())
Break2:
}
}
if err := scanner.Err(); err != nil {
log.Println("Warning: Importing Collection \"" + path + "\":" + err.Error())
}
err = collectionHelper.SetFilterCollection(collection)
if err != nil {
log.Println("Warning: Saving Collection \"" + collection.Name + "\":" + err.Error())
}
}
return nil
})
}
/*
* Check if a user has access to a domain using the domain look up (Which should be quicker)
*/
func (t *Developer) quickaccess(response http.ResponseWriter, request *http.Request) {
log.Println("Started")
userFilterCollectionsHelper, err := datastore.GetUserFilterCollectionsHelper()
if err != nil {
log.Println("Error:" + err.Error())
http.Error(response, err.Error(), 500)
return
}
userFilterCollections, err := userFilterCollectionsHelper.GetUserFilterCollections(mux.Vars(request)["username"])
if err != nil {
log.Println("Error:" + err.Error())
http.Error(response, err.Error(), 500)
return
}
filterCollectionHelper, err := datastore.GetFilterCollectionHelper()
if err != nil {
log.Println("Error:" + err.Error())
http.Error(response, err.Error(), 500)
return
}
inCollections, err := filterCollectionHelper.GetFilterCollectionsWithDomain(mux.Vars(request)["domain"])
if err != nil {
log.Println("Error:" + err.Error())
http.Error(response, err.Error(), 500)
return
}
for _, collection := range inCollections {
for _, userCollectionName := range userFilterCollections.Collections {
if userCollectionName == collection.Name {
log.Println("Blocked")
return
}
}
}
log.Println("Not Blocked")
}
/**
* Displays the list of collections.
*/
func (t *Collection) index(response http.ResponseWriter, request *http.Request) {
// Get the current session user.
myuser := t.Sessions.CurrentUser(response, request)
// Get all collections.
filterCollectionDataStoreHelper, err := datastore.GetFilterCollectionHelper()
allCollections, err := filterCollectionDataStoreHelper.GetFilterCollections()
// Check for error when loading collections.
if err != nil {
http.Error(response, err.Error(), 500)
return
}
// Retrieve the savecomplete parameter from the URL and determine if it is true or not.
saveCompleteParam := request.URL.Query().Get("savecomplete")
saveComplete := saveCompleteParam == "true"
// Retrieve the saveerror parameter from the URL and determine if it is true or not.
saveErrorParam := request.URL.Query().Get("saveerror")
saveError := saveErrorParam == "true"
// Setup the data structure to pass to the page.
data := struct {
Action string
User datastore.User
AllCollections []datastore.FilterCollection
SaveComplete bool
SaveError bool
}{
"collectionSettings",
myuser,
allCollections,
saveComplete,
saveError,
}
// Parse the page and execute the template.
tpl, _ := template.ParseFiles("static/main.tpl", "static/main_authenticated.tpl", "static/collections/index.tpl")
tpl.Execute(response, data)
}
/**
* Handles deleting a collection.
*/
func (t *Collection) remove(response http.ResponseWriter, request *http.Request) {
// Try and load a filter collection using the collection name.
collectionName := mux.Vars(request)["collection"]
filterCollectionDataStoreHelper, err := datastore.GetFilterCollectionHelper()
if err != nil {
log.Println("DB Error:" + err.Error())
http.Error(response, err.Error(), 500)
return
}
err = filterCollectionDataStoreHelper.DeleteFilterCollection(collectionName)
// Check for error when deleting collection.
if err != nil {
http.Error(response, err.Error(), 500)
return
}
http.Redirect(response, request, t.Base(), http.StatusMovedPermanently)
}
/**
* Handles adding and removing urls for the collection.
*/
func (t *Collection) edit(response http.ResponseWriter, request *http.Request) {
// Get the current session user.
myuser := t.Sessions.CurrentUser(response, request)
// Get the collection.
collectionName := mux.Vars(request)["collection"]
filterCollectionDataStoreHelper, err := datastore.GetFilterCollectionHelper()
if err != nil {
log.Println("DB Error:" + err.Error())
http.Error(response, err.Error(), 500)
return
}
collection, err := filterCollectionDataStoreHelper.GetFilterCollection(collectionName)
// Check for error when loading collection.
if err != nil {
http.Error(response, err.Error(), 500)
return
}
// Setup the data structure to pass to the page.
data := struct {
Action string
User datastore.User
Collection datastore.FilterCollection
}{
"collectionSettings",
myuser,
collection,
}
// Parse the page and execute the template.
tpl, _ := template.ParseFiles("static/main.tpl", "static/main_authenticated.tpl", "static/collections/edit.tpl")
tpl.Execute(response, data)
}
/**
* Gets the list of blocked sites that match the given filter and returns as JSON response.
*/
func (t *Collection) getFilterSiteList(response http.ResponseWriter, request *http.Request) {
name := request.FormValue("collection")
filter := request.FormValue("filter")
log.Println(name)
log.Println(filter)
filterCollectionDataStoreHelper, err := datastore.GetFilterCollectionHelper()
collection, err := filterCollectionDataStoreHelper.GetFilterCollection(name)
// Check for error when loading collection.
if err != nil {
http.Error(response, err.Error(), 500)
return
}
// Setup the data structure to return.
data := struct {
Sites []string
}{
collection.Domains,
}
enc := json.NewEncoder(response)
enc.Encode(data)
}
/**
* Handles saving a collection.
*/
func (t *Collection) save(response http.ResponseWriter, request *http.Request) {
filterCollectionDataStoreHelper, err := datastore.GetFilterCollectionHelper()
if err != nil {
log.Println("DB Error:" + err.Error())
http.Error(response, err.Error(), 500)
return
}
collection := datastore.FilterCollection{}
collection.Name = request.FormValue("name")
// Save the collection.
err = filterCollectionDataStoreHelper.SetFilterCollection(collection)
// Check for error when saving collection.
if err != nil {
// There was an error, so report that to the screen.
http.Redirect(response, request, "/settings_collections.html?saveerror=true", http.StatusMovedPermanently)
} else {
// No error, so report a successful save to the screen
http.Redirect(response, request, t.Base()+"?savecomplete=true", http.StatusMovedPermanently)
}
}
func Hijack(response dns.ResponseWriter, message *dns.Msg) (bool, error) {
if (message.Question[0].Qtype == dns.TypeA || message.Question[0].Qtype == dns.TypeAAAA) && message.Question[0].Qclass == dns.ClassINET {
ipString, _, err := net.SplitHostPort(response.RemoteAddr().String())
if err != nil {
log.Println("Warning: Received No IP4 Address:" + response.RemoteAddr().String())
return false, err
}
ip := net.ParseIP(ipString)
deviceHelper, err := datastore.GetDeviceHelper()
if err != nil {
log.Println("Error: Datastore Error (Open Access):" + err.Error())
return false, err
}
device, err := deviceHelper.GetDeviceByIP(ip)
if err != nil {
log.Println("Error: Datastore Error (Open Access):" + err.Error())
return false, err
}
if bytes.Equal(device.MACAddress, net.HardwareAddr{}) {
//Device Doesn't exists?
log.Println("Warning: IP:" + ipString + " MAC:" + device.MACAddress.String() + " Doesn't Exists As A Local Device But is Using Our DNS??")
return false, nil
} else {
if activeUser := device.GetActiveUser(); activeUser != nil {
//User is active check they have access.
userFiltercollectionsHelper, err := datastore.GetUserFilterCollectionsHelper()
if err != nil {
return false, err
}
usersFiltercollection, err := userFiltercollectionsHelper.GetUserFilterCollections(activeUser.Username)
if err != nil {
return false, err
}
if usersFiltercollection.Username != "" {
//Get the collections helper.
filterCollectionsHelper, err := datastore.GetFilterCollectionHelper()
if err != nil {
return false, err
}
//Start Moving down the domain (i.e. removing subdomains etc)
collections := make([]datastore.FilterCollection, 0)
domain := strings.TrimSuffix(message.Question[0].Name, ".")
for {
additionalCollections, err := filterCollectionsHelper.GetFilterCollectionsWithDomain(domain)
if err != nil {
return false, err
}
if len(additionalCollections) > 0 {
collections = append(collections, additionalCollections...)
}
if len(strings.SplitAfterN(domain, ".", 2)) == 2 {
domain = strings.SplitAfterN(domain, ".", 2)[1]
} else {
break
}
}
//Does the domain appear in any collections??
for _, collection := range collections {
if usersFiltercollection.ContainsCollection(collection.Name) {
//The Url Should be blocked...
//For Now lets just not respond with a DNS record...
//localResponse := new(dns.Msg)
//localResponse.SetReply(message)
//rr_header := dns.RR_Header{Name: message.Question[0].Name, Class: dns.ClassINET, Ttl: 0}
//Main Active IP
//mainIPNetwork, err := networktools.MainActiveIPNetwork()
//if err != nil {
// return false, err
//}
//switch message.Question[0].Qtype {
//case dns.TypeA:
// rr_header.Rrtype = dns.TypeA
// a := &dns.A{rr_header, mainIPNetwork.IP}
// localResponse.Answer = append(localResponse.Answer, a)
//case dns.TypeAAAA:
// rr_header.Rrtype = dns.TypeAAAA
//}
//err = response.WriteMsg(localResponse)
//if err != nil {
// return false, err
//}
return true, nil
}
}
return false, nil
}
} else {
//User is not active redirect to login page.
localResponse := new(dns.Msg)
localResponse.SetReply(message)
rr_header := dns.RR_Header{Name: message.Question[0].Name, Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 0}
//Main Active IP
mainIPNetwork, err := networktools.MainActiveIPNetwork()
if err != nil {
return false, err
}
a := &dns.A{rr_header, mainIPNetwork.IP}
localResponse.Answer = append(localResponse.Answer, a)
err = response.WriteMsg(localResponse)
if err != nil {
return false, err
}
return true, nil
}
}
}
return false, nil
}
/**
* Handles editing a user filter collections object.
*/
func (t *UsersCollections) edit(response http.ResponseWriter, request *http.Request) {
// Get the current session user.
myuser := t.Sessions.CurrentUser(response, request)
// Get the user filter collections.
username := mux.Vars(request)["username"]
userFilterCollectionsHelper, err := datastore.GetUserFilterCollectionsHelper()
if err != nil {
log.Println("DB Error:" + err.Error())
http.Error(response, err.Error(), 500)
return
}
userFilterCollections, err := userFilterCollectionsHelper.GetUserFilterCollections(username)
// Check for error when loading user filter collection.
if err != nil {
http.Error(response, err.Error(), 500)
return
}
// Get the user relating to the filter collection.
userDataStoreHelper, err := datastore.GetUserHelper()
if err != nil {
log.Println("DB Error:" + err.Error())
http.Error(response, err.Error(), 500)
return
}
filterCollectionsUser, err := userDataStoreHelper.GetUser(username)
// Check for error when loading user.
if err != nil {
http.Error(response, err.Error(), 500)
return
}
// Get all collections to display on the page.
filterCollectionHelper, err := datastore.GetFilterCollectionHelper()
allCollections, err := filterCollectionHelper.GetFilterCollections()
// Check for error when loading collections.
if err != nil {
http.Error(response, err.Error(), 500)
return
}
// Setup the data structure to pass to the page.
data := struct {
Action string
User datastore.User
UserFilterCollections datastore.UserFilterCollections
FilterCollectionsUser *datastore.User
AllCollections []datastore.FilterCollection
}{
"userAccessSettings",
myuser,
userFilterCollections,
&filterCollectionsUser,
allCollections,
}
// Parse the page and execute the template.
tpl, _ := template.ParseFiles("static/main.tpl", "static/main_authenticated.tpl", "static/access/edit.tpl")
tpl.Execute(response, data)
}