ipbl/src/models/ip.go

package models

import (
	"context"
	"database/sql"
	"fmt"
	"log"
	"net"
	"time"

	"git.paulbsd.com/paulbsd/ipbl/src/api"
	"git.paulbsd.com/paulbsd/ipbl/src/config"
)

// GetIPs ...
func GetIPs(ctx *context.Context, config *config.Config, limit int) (apimailboxes []*api.IP, err error) {
	var ips []IP
	err = config.Db.Limit(limit).Desc("created").Find(&ips)
	for _, ml := range ips {
		apimailboxes = append(apimailboxes, ml.APIFormat())
	}
	return
}

// GetIPs ...
func GetIPsLastDay(ctx *context.Context, config *config.Config, interval string) (apimailboxes []*api.IP, err error) {
	var ips []IP
	err = config.Db.Where(fmt.Sprintf("created >= (now()-'%s'::interval)", interval)).Desc("created").Find(&ips)
	for _, ml := range ips {
		apimailboxes = append(apimailboxes, ml.APIFormat())
	}
	return
}

// GetIP ...
func GetIP(ctx *context.Context, config *config.Config, ipquery interface{}) (apiip *api.IP, err error) {
	var ip IP
	has, err := config.Db.Where("ip = ?", ipquery).Get(&ip)
	if !has {
		err = fmt.Errorf("Not Found")
		return nil, err
	}
	if err != nil {
		return
	}
	apiip = ip.APIFormat()
	return
}

// UpdateRDNS ...
func (i *IP) UpdateRDNS() (result string, err error) {
	res, err := net.LookupAddr(i.IP)
	if err != nil {
		result = ""
	} else {
		result = res[0]
	}
	return
}

// InsertIP ...
func (i *IP) InsertIP(cfg *config.Config) (num int64, err error) {
	num, err = cfg.Db.Insert(i)
	return
}

// InsertIPBulk ...
func InsertIPBulk(cfg *config.Config, ips *[]IP) (numinserts int64, numupdates int64, numfail int64, err error) {
	for _, ip := range *ips {
		s_ip := IP{IP: ip.IP}
		res, _ := cfg.Db.Get(&s_ip)
		if res {
			num, err := cfg.Db.ID(s_ip.ID).Update(&s_ip)
			if err != nil {
				numfail++
				continue
			}
			numupdates += num
		} else {
			num, err := cfg.Db.Insert(ip)
			if err != nil {
				numfail++
				continue
			}
			numinserts += num
		}
	}
	return
}

// ScanIP ...
func ScanIP(cfg *config.Config) (err error) {
	for {
		var orphans = []IP{}
		cfg.Db.Where("rdns IS NULL").Asc("ip").Find(&orphans)
		if len(orphans) > 0 {
			for _, i := range orphans {
				reverse, _ := i.UpdateRDNS()
				if reverse == "" {
					log.Printf("Set \"none\" rdns to IP %s\n", i.IP)
					i.Rdns.String = "none"
				} else {
					log.Printf("%s %s\n", i.IP, reverse)
					i.Rdns.String = reverse
				}
				i.Rdns.Valid = true
				_, err = cfg.Db.ID(i.ID).Cols("rdns").Update(&i)
				if err != nil {
					log.Println(err)
				}
			}
		} else {
			time.Sleep(60 * time.Second)
		}
	}
}

// APIFormat returns a JSON formatted object of IP
func (ip *IP) APIFormat() *api.IP {
	if ip == nil {
		return nil
	}
	return &api.IP{
		ID:   ip.ID,
		IP:   ip.IP,
		Rdns: ip.Rdns.String,
		Src:  ip.Src,
	}
}

// IP describe IP objects
type IP struct {
	ID      int            `xorm:"pk autoincr" json:"-"`
	IP      string         `xorm:"text notnull unique(ipsrc)" json:"ip"`
	Rdns    sql.NullString `xorm:"text default" json:"rdns"`
	Src     string         `xorm:"text notnull unique(ipsrc)" json:"src"`
	Created time.Time      `xorm:"created notnull" json:"-"`
	Updated time.Time      `xorm:"updated notnull" json:"-"`
}