Example #1
0
// mainLoop initiates all ports and handles the traffic
func mainLoop() {
	openPorts()
	defer closePorts()

	log.Println("Waiting for configuration IP...")
	var options *bonjour.ServiceEntry
	for {
		ip, err := inPort.RecvMessageBytes(0)
		if err != nil {
			log.Println("Error receiving IP:", err.Error())
			continue
		}
		if !runtime.IsValidIP(ip) || !runtime.IsPacket(ip) {
			continue
		}
		if err = json.Unmarshal(ip[1], &options); err != nil {
			log.Println("Error decoding options:", err.Error())
			continue
		}
		inPort.Close()
		break
	}

	log.Println("Started...")
	var err error
	bonjourCh, err = bonjour.Register(options.Instance, options.Service, options.Domain, options.Port, options.Text, nil)
	if err != nil {
		log.Println("Error registering service:", err.Error())
		exitCh <- syscall.SIGTERM
		return
	}

	// Block execution
	select {}
}
Example #2
0
func registerService(serverPort uint16) bool {
	hostname, err := os.Hostname()
	if err != nil {
		log.Fatalln("Failed to fetch hostname")
	}

	txt := []string{"host=" + hostname}
	registered := registerServiceViaDBusAvahi("Reveller", "_reveller._tcp", serverPort, txt)
	if !registered {
		_, err := bonjour.Register("Reveller", "_reveller._tcp", "local", int(serverPort), txt, nil)
		if err != nil {
			return false
		}
	}

	return true
}
Example #3
0
func main() {
	fmt.Println("hello")

	ln, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
	if err != nil {
		fmt.Println(err.Error())
		os.Exit(1)
	}
	go func() {
		i := 1
		for {
			conn, err := ln.Accept()
			if err != nil {
				fmt.Println(err.Error())
				os.Exit(1) // TODO
			}
			fmt.Printf("incoming connection from %s\n", conn.RemoteAddr())
			go handleSession(strconv.Itoa(i), conn)
			i++
		}
	}()

	iface, err := net.InterfaceByName(iface)
	if err != nil {
		fmt.Println(err.Error())
		os.Exit(1)
	}
	bName := hex.EncodeToString(iface.HardwareAddr) + "@" + name
	s, err := bonjour.Register(bName, "_raop._tcp", "", port, txt, nil)
	if err != nil {
		fmt.Println(err.Error())
		os.Exit(1)
	}
	defer s.Shutdown()

	handler := make(chan os.Signal, 1)
	signal.Notify(handler, os.Interrupt)
	for sig := range handler {
		if sig == os.Interrupt {
			time.Sleep(100 * time.Millisecond)
			break
		}
	}
}