Golang TCPConn.ReadFrom方法代码示例

// Serve Gopher clients
func (s *Server) Serve(c *net.TCPConn) {
	defer c.Close()

	p, err := s.getPath(c)
	if err != nil {
		fmt.Fprint(c, s.ErrorListing("invalid request"))

		return
	}

	fn := s.filename(p)

	fi, err := os.Stat(fn)
	if err != nil {
		fmt.Fprint(c, s.ErrorListing("not found"))

		return
	}

	if fi.IsDir() {
		var list Listing

		filepath.Walk(fn, func(path string, info os.FileInfo, err error) error {
			if info.IsDir() {
				return list.VisitDir(info.Name(), path, s.Root, s.Host, s.Port)
			}

			list.VisitFile(info.Name(), path, s.Root, s.Host, s.Port)

			return nil
		})

		fmt.Fprint(c, list)

		return
	}

	f, err := os.Open(fn)
	if err != nil {
		fmt.Fprint(c, s.ErrorListing("couldn't open file"))
		return
	}
	defer f.Close()

	c.ReadFrom(f)
}

func send(conn *net.TCPConn, file string) {
	fh, err := os.Open(file)
	if err != nil {
		log.Fatalln(err)
	}
	stat, _ := fh.Stat()
	b := make([]byte, 8)
	binary.BigEndian.PutUint64(b, uint64(stat.Size()))
	_, err = conn.Write(b)
	if err != nil {
		log.Fatal(err)
	}
	r := bufio.NewReader(fh)
	n, err := conn.ReadFrom(r)
	if err != nil {
		log.Fatalln("send err ", err)
	}
	log.Println("file send size: ", n)
}

func serveHTTPS(conn *net.TCPConn, reader *bufio.Reader, codeline, headers, piece string) {
	this := func(target string) string {
		for i, rule := range regex {
			if rule.MatchString(target) {
				return proxy[i].Host
			}
		}
		return target
	}(piece)
	raddr, err := net.ResolveTCPAddr("tcp", this)
	for i := 0; i < 5 && err != nil; i++ {
		time.Sleep(time.Duration(i) * time.Second)
		raddr, err = net.ResolveTCPAddr("tcp", this)
	}
	if err != nil {
		log.Println("Parse Https:", codeline, piece, err)
		return
	}
	tcpconn, err := net.DialTCP("tcp", nil, raddr)
	if err != nil {
		// log.Println("Connect:", err)
		return
	}
	defer tcpconn.Close()
	if this == piece {
		conn.Write([]byte("HTTP/1.0 200 OK\r\n\r\n"))
	} else {
		tcpconn.Write([]byte(codeline + headers))
	}
	go func() {
		if _, err := tcpconn.ReadFrom(reader); err != nil {
			// log.Println("ReadFrom Left:", err)
			return
		}
	}()
	if _, err = conn.ReadFrom(tcpconn); err != nil {
		// log.Println("ReadFrom Right:", err)
		return
	}
}

/* Builds and populates Switch struct then starts listening
for OpenFlow messages on conn. */
func NewOpenFlowSwitch(conn *net.TCPConn) {

	if _, err := conn.ReadFrom(ofp10.NewHello()); err != nil {
		log.Println("ERROR::Switch.SendSync::ReadFrom:", err)
		conn.Close()
	}
	buf := make([]byte, 1500)
	n, _ := conn.Read(buf)
	res := ofp10.NewHello()
	res.Write(buf[:n])

	if _, err := conn.ReadFrom(ofp10.NewFeaturesRequest()); err != nil {
		log.Println("ERROR::Switch.SendSync::ReadFrom:", err)
		conn.Close()
	}
	buf2 := make([]byte, 1500)
	fres := ofp10.NewFeaturesReply()
	n, _ = conn.Read(buf2)
	fres.Write(buf2[:n])

	if sw, ok := Switches[fres.DPID.String()]; ok {
		log.Println("Recovered connection from:", sw.DPID)
		sw.conn = *conn
		go sw.SendSync()
		go sw.Receive()
	} else {
		log.Printf("Openflow 1.%d Connection: %s", res.Version-1, fres.DPID.String())
		s := new(Switch)
		s.conn = *conn
		s.DPID = fres.DPID
		s.Ports = make(map[int]ofp10.OfpPhyPort)
		s.requests = make(map[uint32]chan ofp10.OfpMsg)
		for _, p := range fres.Ports {
			s.Ports[int(p.PortNo)] = p
		}
		go s.SendSync()
		go s.Receive()
		Switches[s.DPID.String()] = s
	}
}

func Serve(c *net.TCPConn) {
	defer c.Close()
	connbuf := bufio.NewReader(c)
	p, _, err := connbuf.ReadLine()
	if err != nil {
		fmt.Fprint(c, Error("invalid request"))
		return
	}
	filename := root + filepath.Clean("/"+string(p))
	fi, err := os.Stat(filename)
	if err != nil {
		fmt.Fprint(c, Error("not found"))
		return
	}
	if fi.IsDir() {
		var list Listing
		walkFn := func(path string, info os.FileInfo, err error) error {
			if info.IsDir() {
				return list.VisitDir(path, info)
			}

			list.VisitFile(path, info)
			return nil
		}

		PrintInlineText(c, header)

		filepath.Walk(filename, walkFn)
		fmt.Fprint(c, list)
		PrintInlineText(c, footer)
		return
	}
	f, err := os.Open(filename)
	if err != nil {
		fmt.Fprint(c, Error("couldn't open file"))
		return
	}
	c.ReadFrom(f)
}

func copy(dst, src *net.TCPConn) {
	dst.ReadFrom(src)
	src.Close()
	dst.Close()
}

// Sendfile sends count bytes from f to remote a TCP connection.
// f offset is always relative to the current offset.
func Sendfile(conn *net.TCPConn, f *os.File, count int64) (n int64, err error) {
	lr := &io.LimitedReader{N: count, R: f}
	n, err = conn.ReadFrom(lr)
	return
}