Statements und senuma

spargcom/gocart/gocart.go

@@ -2,13 +2,77 @@ package main
 
 import (
 	"fmt"
-	"spargcom/gocart/domain"
+	"io"
+	"log"
+	"net"
+	"os"
+	"os/signal"
 )
 
-var newUser domain.User
-
+/*var addrP *net.TCPAddr
+var err error
+var exp int
+var localipport *net.TCPAddr
+*/
 func main() {
-	newUser.Id = 1
-	fmt.Println(newUser.Id)
+	//addrFlag := flag.String("address", "localhost:9099", "Enter address including Port to listen to")
+	//expPortFlag := flag.Int("exposed", 80, "Enter port to expose")
+	/*flag.Parse()
+
+	  if len(*addrFlag) != 0 {
+	          addrP, err = net.ResolveTCPAddr("tcp", *addrFlag)
+	          if err != nil {
+	                  log.Fatalln("Invalid address:", *addrFlag)
+	          }
+
+	  }
+
+	  if (*expPortFlag) != 0 {
+	          exp = *expPortFlag
+	  } */
+	defer log.Println("-> Closing...")
+	signals := make(chan os.Signal, 1)
+	stop := make(chan bool)
+	signal.Notify(signals, os.Interrupt)
+	go func() {
+		for _ = range signals {
+			fmt.Println("\nReceived an interrupt, stopping...")
+			stop <- true
+		}
+	}()
+
+	sconn, err := net.Listen("tcp", ":9099")
+	if err != nil {
+		log.Fatalln("-> local Connection: ", err)
+		os.Exit(1)
+	}
+	log.Println("server running on Port 9099")
+
+	handsh, err := sconn.Accept()
+	defer handsh.Close()
+	if err != nil {
+		log.Fatalln("-> Could not finalize handshake")
+	}
+
+	log.Println("-> Connection to ", handsh.RemoteAddr())
+
+	log.Println("-> preparing tunnel")
+	client, err := net.Listen("tcp", "0.0.0.0:")
+	if err != nil {
+		log.Fatalln("-> Could not open server port on ", client.Addr())
+	}
+	log.Println("-> server running on port ", client.Addr())
+	conn, err := client.Accept()
+	defer conn.Close()
+	if err != nil {
+		log.Fatalln("-> could not accept client connection")
+	}
+
+	log.Println("-> connection to client ", conn.RemoteAddr())
+
+	go func() { io.Copy(conn, handsh) }()
+	go func() { io.Copy(handsh, conn) }()
+
+	<-stop
 
 }

spargcom/gocart/gocartc/gocartc.go

@@ -0,0 +1,67 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"net"
+	"os"
+	"os/signal"
+	"strconv"
+)
+
+var addrP *net.TCPAddr
+var err error
+var exp int
+
+// var localipport *net.TCPAddr
+
+func main() {
+	addrFlag := flag.String("address", "10.1.179.88:9099", "Enter address including Port to listen to")
+	expPortFlag := flag.Int("exposed", 80, "Enter port to expose")
+	flag.Parse()
+
+	if len(*addrFlag) != 0 {
+		addrP, err = net.ResolveTCPAddr("tcp", *addrFlag)
+		if err != nil {
+			log.Fatalln("Invalid address:", *addrFlag)
+		}
+
+	}
+
+	if (*expPortFlag) != 0 {
+		exp = *expPortFlag
+	}
+
+	createConn(addrP, exp)
+
+}
+
+func createConn(addr *net.TCPAddr, export int) {
+	defer log.Println("-> Closeing...")
+	signals := make(chan os.Signal, 1)
+	stop := make(chan bool)
+	signal.Notify(signals, os.Interrupt)
+	go func() {
+		for _ = range signals {
+			fmt.Println("\nReceived an interrupt, stopping...")
+			stop <- true
+		}
+	}()
+
+	inconn, err := net.DialTCP("tcp", nil, addr)
+	if err != nil {
+		log.Fatalln("-> Connection: ", err)
+	}
+	log.Println("-> Connection to ", addr)
+	expconn, err := net.Dial("tcp", "localhost:"+strconv.Itoa(export))
+	if err != nil {
+		log.Fatalln("-> local forward Connection: ", err)
+	}
+	log.Println("-> Connection to local Port", export)
+	go func() { io.Copy(inconn, expconn) }()
+	go func() { io.Copy(expconn, inconn) }()
+
+	<-stop
+}

spargcom/senuma/database/database.go

@@ -0,0 +1,120 @@
+package database
+
+import (
+	"database/sql"
+	"fmt"
+	"spargcom/gocart/domain"
+	"time"
+
+	_ "github.com/go-sql-driver/mysql"
+)
+
+var (
+	dbConnection = "gocuser:123456@tcp(10.1.1.6:3300)/gocart"
+	dbType       = "mysql"
+)
+
+func CreatePackage(pk domain.Package) (resPk domain.Package, err error) {
+	conn, err := sql.Open(dbType, dbConnection)
+	if err != nil {
+		fmt.Println("Error while connecting DB: ", err)
+	}
+	fmt.Println("Verbindung hergestellt")
+	fmt.Println("Name = ", pk.Name)
+	defer conn.Close()
+
+	res, err := conn.Exec("INSERT INTO package VALUES(?,?,?,?,?)", pk.Id, pk.Name, pk.Amount, pk.Price, pk.IsActive)
+	if err != nil {
+		fmt.Println("Error while executing insert statement", err)
+	}
+	lastId, err := res.LastInsertId()
+	pk.Id = uint(lastId)
+	resPk = pk
+
+	return resPk, err
+}
+
+func CreateUser(us domain.User) (resUs domain.User, err error) {
+	conn, err := sql.Open(dbType, dbConnection)
+	if err != nil {
+		fmt.Println("Error while connecting DB: ", err)
+	}
+	fmt.Println("Verbindung hergestellt")
+	defer conn.Close()
+	stmt, err := conn.Prepare("INSERT INTO `user` (`id`, `username`, `full_name`, `email`, `group_id`, `is_active`, `is_admin`, `password`) VALUES(?,?,?,?,?,?,?,?)")
+	res, err := stmt.Exec(us.Id, us.Username, us.FullName, us.Email, us.GroupId, us.IsActive, us.IsAdmin, us.Password)
+	if err != nil {
+		fmt.Println("Error while executing insert statement", err)
+	}
+	lastId, err := res.LastInsertId()
+	us.Id = uint(lastId)
+	resUs = us
+
+	return resUs, err
+}
+
+func CreateGroup(grp domain.Group) (resGrp domain.Group, err error) {
+	conn, err := sql.Open(dbType, dbConnection)
+	if err != nil {
+		fmt.Println("Error while connecting DB: ", err)
+	}
+	fmt.Println("Verbindung hergestellt")
+	defer conn.Close()
+	stmt, err := conn.Prepare("INSERT INTO `group` (`id`, `name`, `booked_package`, `billing_address`, `auth_token`, `is_active`, `billing_user`) VALUES(?,?,?,?,?,?,?)")
+	res, err := stmt.Exec(grp.Id, grp.Name, grp.BookedPackage, grp.BillingAddress, grp.AuthToken, grp.IsActive, grp.BillingUser)
+	if err != nil {
+		fmt.Println("Error while executing insert statement", err)
+	}
+	lastId, err := res.LastInsertId()
+	grp.Id = uint(lastId)
+	resGrp = grp
+
+	return resGrp, err
+}
+
+func CreateAccount(us domain.User) (resAcc domain.Account, err error) {
+
+	var acc domain.Account
+	fmt.Println("User ID:", us.Id)
+	fmt.Println("Group ID:", us.GroupId)
+	conn, err := sql.Open(dbType, dbConnection)
+	if err != nil {
+		fmt.Println("Error while connecting DB: ", err)
+	}
+	fmt.Println("Verbindung hergestellt")
+	defer conn.Close()
+	stmt, err := conn.Prepare("INSERT INTO `account` (`id`, `group_id`, `created`, `is_active`) VALUES(?,?,?,?)")
+
+	res, err := stmt.Exec(acc.Id, us.GroupId, time.Now(), acc.IsActive)
+	if err != nil {
+		fmt.Println("Error while executing insert statement", err)
+	}
+	lastId, err := res.LastInsertId()
+	acc.Id = uint(lastId)
+	resAcc = acc
+	fmt.Println("Created")
+	return resAcc, err
+
+}
+
+func CreateTunnel(tun domain.Tunnel) (resTun domain.Tunnel, err error) {
+	fmt.Println("Adding tunnel to database...")
+	conn, err := sql.Open(dbType, dbConnection)
+	if err != nil {
+		fmt.Println("Error while connecting DB: ", err)
+
+	}
+	fmt.Println("Verbindung hergestellt")
+	defer conn.Close()
+	stmt, err := conn.Prepare("INSERT INTO `tunnels` (`id`, `name`, `port`, `is_active`, `created`, `routed_name`, `routed_port`, `account_id`) VALUES(?,?,?,?,?,?,?,?)")
+
+	res, err := stmt.Exec(tun.Id, tun.Name, tun.Port, tun.IsActive, time.Now(), tun.RoutedName, tun.RoutedPort, tun.AccountId)
+	if err != nil {
+		fmt.Println("Error while executing insert statement", err)
+	}
+	lastId, err := res.LastInsertId()
+	tun.Id = uint64(lastId)
+	resTun = tun
+	fmt.Println("Created")
+	return resTun, err
+}

spargcom/senuma/database/go.mod

@@ -0,0 +1,5 @@
+module database.go
+
+go 1.16
+
+require github.com/go-sql-driver/mysql v1.6.0

spargcom/senuma/database/go.sum

@@ -0,0 +1,2 @@
+github.com/go-sql-driver/mysql v1.6.0 h1:BCTh4TKNUYmOmMUcQ3IipzF5prigylS7XXjEkfCHuOE=
+github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=

spargcom/senuma/domain/domain.go

@@ -0,0 +1,48 @@
+package domain
+
+type Package struct {
+	Id       uint    `json:"id"`
+	Name     string  `json:"name"`
+	Amount   int     `json:"amount"`
+	Price    float32 `json:"price"`
+	IsActive bool    `json:"isActive"`
+}
+
+type Group struct {
+	Id             uint   `json:"id"`
+	Name           string `json:"name"`
+	BookedPackage  int    `json:"bookedPackage"`
+	BillingAddress string `json:"billingAddress"`
+	AuthToken      string `json:"authToken"`
+	IsActive       bool   `json:"isActive"`
+	BillingUser    int    `json:"billingUser"`
+}
+
+type User struct {
+	Id       uint   `json:"id"`
+	Password string `json:"password"`
+	IsAdmin  bool   `json:"isAdmin"`
+	Username string `json:"username"`
+	FullName string `json:"fullName"`
+	Email    string `json:"email"`
+	GroupId  int    `json:"groupId"`
+	IsActive bool   `json:"isActive"`
+}
+
+type Account struct {
+	Id       uint   `json:"id"`
+	GroupId  int    `json:"groupId"`
+	Created  string `json:"createDate"`
+	IsActive bool   `json:"isActive"`
+}
+
+type Tunnel struct {
+	Id         uint64 `json:"id"`
+	Name       string `json:"name"`
+	Port       int    `json:"port"`
+	IsActive   bool   `json:"isActive"`
+	Created    string `json:"created"`
+	RoutedName string `json:"routedName"`
+	RoutedPort int    `json:"routedPort"`
+	AccountId  uint   `json:"accountId"`
+}

spargcom/senuma/domain/go.mod

@@ -0,0 +1,3 @@
+module domain.go
+
+go 1.16

spargcom/senuma/go.mod

@@ -0,0 +1,3 @@
+module senuma
+
+go 1.16