overflow_discovery/discovery/ipv4/service_tcp.go

package ipv4

import (
	"fmt"
	"net"

	"git.loafle.net/commons_go/logging"
	cnsm "git.loafle.net/commons_go/network_service_matcher"
	cuej "git.loafle.net/commons_go/util/encoding/json"
	oocmd "git.loafle.net/overflow/overflow_commons_go/modules/discovery"
	discoveryM "git.loafle.net/overflow/overflow_commons_go/modules/discovery/model"
	"git.loafle.net/overflow/overflow_discovery/matcher"
)

func scanServiceTCP(port *discoveryM.Port, ds *discoveryM.DiscoveryService, resultChan chan interface{}, errChan chan error, stopChan chan struct{}) bool {

	hostIP := port.Host.IP
	portNumber, err := cuej.NumberToInt(port.PortNumber)
	if err != nil {
		errChan <- fmt.Errorf("Discovery: Service scan on %s:%s error has occurred %v ", hostIP, port.PortNumber, err)
		return false
	}

	info := cnsm.NewMatchInfo(hostIP, portNumber)
	var s *discoveryM.Service

	scs := []serviceConnector{
		&normalServiceConn{
			t: oocmd.PortTypeTCP,
		},
		&tlsServiceConn{
			t: oocmd.CryptoTypeTLS,
		},
	}

	for i := 0; i < len(scs); i++ {
		sc := scs[i]

		conn, err := sc.Dial(hostIP, portNumber)
		if err != nil {
			errChan <- fmt.Errorf("Discovery: Service scan[%s] on %s:%d error has occurred %v ", sc.Type(), hostIP, portNumber, err)
			break
		}
		logging.Logger().Debug(fmt.Sprintf("Discovery: Service scan connected[%s:%d] %s", hostIP, portNumber, sc.Type()))

		buf := make([]byte, 1024)
		rn, err := conn.Read(buf)
		if err != nil {
			rn = 0
		}
		if rn != 0 {
			s = hadlePrePacket(info, sc, conn, cnsm.NewPacket(buf, rn))
		} else {
			conn.Close()
			s = hadlePostPacket(info, sc)
		}

		if nil != s {
			break
		}

		select {
		case <-stopChan:
			return true
		}
	}

	if nil != s {
		s.Port = port
		resultChan <- s
		return true
	}

	return false
}

func hadlePrePacket(info cnsm.MatchInfo, sc serviceConnector, conn net.Conn, packet *cnsm.Packet) *discoveryM.Service {
	defer func() {
		conn.Close()
	}()

	// logging.Logger().Debug(fmt.Sprintf("Discovery: Service scan pre packet length[%d], buf[%v]", packet.Len, packet.Buffer))
	logging.Logger().Debug(fmt.Sprintf("Discovery: Service scan[%s] on %s:%d pre packet length[%d]", sc.Type(), info.IP(), info.Port(), packet.Len))

	ms := matcher.GetTCPMatchers(true)
	buf := make([]byte, 1024)
	var s *discoveryM.Service

Loop:
	for i := 0; i < len(ms); i++ {
		m := ms[i]

		if m.Match(info, 0, packet) {
			packetCount := m.PacketCount()

			if 0 == packetCount {
				s = &discoveryM.Service{
					ServiceName: m.ServiceName(),
					CryptoType:  sc.Type(),
				}
				break Loop
			}

			found := false

			for j := 0; j < packetCount; j++ {
				tPacket := m.Packet(j)
				// logging.Logger().Debug(fmt.Sprintf("Discovery: Service scan send packet length[%d], buf[%v]", tPacket.Len, tPacket.Buffer))
				logging.Logger().Debug(fmt.Sprintf("Discovery: Service scan[%s] on %s:%d send packet length[%d]", sc.Type(), info.IP(), info.Port(), tPacket.Len))
				wn, err := conn.Write(tPacket.Buffer)
				if nil != err {
					logging.Logger().Debug(fmt.Sprintf("Discovery: Service scan[%s] on %s:%d send packet error %v", sc.Type(), info.IP(), info.Port(), err))
					break
				}
				if wn != tPacket.Len {
					logging.Logger().Debug(fmt.Sprintf("Discovery: Service scan[%s] on %s:%d send packet length[%d] not same with %d", sc.Type(), info.IP(), info.Port(), wn, tPacket.Len))
					break
				}

				rn, err := conn.Read(buf)
				if nil != err {
					logging.Logger().Debug(fmt.Sprintf("Discovery: Service scan[%s] on %s:%d receive packet error %v", sc.Type(), info.IP(), info.Port(), err))
					break
				}

				if m.Match(info, j+1, cnsm.NewPacket(buf, rn)) {
					// logging.Logger().Debug(fmt.Sprintf("Discovery: Service scan receive match length[%d], buf[%v]", rn, buf))
					logging.Logger().Debug(fmt.Sprintf("Discovery: Service scan[%s] on %s:%d receive match length[%d]", sc.Type(), info.IP(), info.Port(), rn))
					found = true
				} else {
					// logging.Logger().Debug(fmt.Sprintf("Discovery: Service scan receive not match length[%d], buf[%v]", rn, buf))
					logging.Logger().Debug(fmt.Sprintf("Discovery: Service scan[%s] on %s:%d receive not match length[%d]", sc.Type(), info.IP(), info.Port(), rn))
					found = false
					break
				}
			}

			if found {
				s = &discoveryM.Service{
					ServiceName: m.ServiceName(),
					CryptoType:  sc.Type(),
				}
				break Loop
			}
		}
	}

	return s
}

func hadlePostPacket(info cnsm.MatchInfo, sc serviceConnector) *discoveryM.Service {
	ms := matcher.GetTCPMatchers(false)
	buf := make([]byte, 1024)
	var s *discoveryM.Service

Loop:
	for i := 0; i < len(ms); i++ {
		m := ms[i]

		conn, err := sc.Dial(info.IP(), info.Port())
		if err != nil {
			logging.Logger().Debug(fmt.Sprintf("Discovery: Service scan[%s] on %s:%d socket dial error %v", sc.Type(), info.IP(), info.Port(), err))
			break Loop
		}

		packetCount := m.PacketCount()
		for j := 0; j < packetCount; j++ {
			tPacket := m.Packet(j)
			// logging.Logger().Debug(fmt.Sprintf("Discovery: Service scan send packet length[%d], buf[%v]", tPacket.Len, tPacket.Buffer))
			logging.Logger().Debug(fmt.Sprintf("Discovery: Service scan[%s] on %s:%d send packet length[%d]", sc.Type(), info.IP(), info.Port(), tPacket.Len))
			wn, err := conn.Write(tPacket.Buffer)
			if nil != err {
				logging.Logger().Debug(fmt.Sprintf("Discovery: Service scan[%s] on %s:%d send packet error %v", sc.Type(), info.IP(), info.Port(), err))
				break
			}
			if wn != tPacket.Len {
				logging.Logger().Debug(fmt.Sprintf("Discovery: Service scan[%s] on %s:%d send packet length[%d] not same with %d", sc.Type(), info.IP(), info.Port(), wn, tPacket.Len))
				break
			}

			rn, err := conn.Read(buf)
			if nil != err {
				if !m.HasResponse(j) {
					s = &discoveryM.Service{
						ServiceName: m.ServiceName(),
						CryptoType:  sc.Type(),
					}
					break
				}

				logging.Logger().Debug(fmt.Sprintf("Discovery: Service scan[%s] on %s:%d receive packet error %v", sc.Type(), info.IP(), info.Port(), err))
				break
			}

			if m.Match(info, j, cnsm.NewPacket(buf, rn)) {
				if packetCount-1 == j {
					s = &discoveryM.Service{
						ServiceName: m.ServiceName(),
						CryptoType:  sc.Type(),
					}
					break
				}

				// logging.Logger().Debug(fmt.Sprintf("Discovery: Service scan receive match length[%d], buf[%v]", rn, buf))
				logging.Logger().Debug(fmt.Sprintf("Discovery: Service scan[%s] on %s:%d receive match length[%d]", sc.Type(), info.IP(), info.Port(), rn))
				continue
			} else {
				// logging.Logger().Debug(fmt.Sprintf("Discovery: Service scan receive not match length[%d], buf[%v]", rn, buf))
				logging.Logger().Debug(fmt.Sprintf("Discovery: Service scan[%s] on %s:%d receive not match length[%d]", sc.Type(), info.IP(), info.Port(), rn))
				break
			}
		}
		conn.Close()

		if nil != s {
			break Loop
		}
	}

	return s
}