container_discovery/internal/discoverer/ipv4/service_tcp.go

package ipv4

import (
	"fmt"
	"net"

	"git.loafle.net/commons/logging-go"
	csm "git.loafle.net/commons/service_matcher-go"
	cuej "git.loafle.net/commons/util-go/encoding/json"
	occc "git.loafle.net/overflow/commons-go/core/constants"
	ocdm "git.loafle.net/overflow/commons-go/discovery/model"
	"git.loafle.net/overflow/container_discovery/internal/matcher"
)

func scanServiceTCP(port *ocdm.Port, ds *ocdm.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 := csm.NewMatchInfo(hostIP, portNumber)
	var s *ocdm.Service

	scs := []serviceConnector{
		&normalServiceConn{
			t: occc.PortTypeTCP.String(),
		},
		&tlsServiceConn{
			t: occc.CryptoTypeTLS.String(),
		},
	}

	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().Debugf("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, csm.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 csm.MatchInfo, sc serviceConnector, conn net.Conn, packet *csm.Packet) *ocdm.Service {
	defer func() {
		conn.Close()
	}()

	// logging.Logger().Debugf("Discovery: Service scan pre packet length[%d], buf[%v]", packet.Len, packet.Buffer)
	logging.Logger().Debugf("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 *ocdm.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 = &ocdm.Service{
					ServiceName: m.Name(),
					CryptoType:  occc.ToCryptoType(sc.Type()),
				}
				break Loop
			}

			found := false

			for j := 0; j < packetCount; j++ {
				tPacket := m.Packet(j)
				// logging.Logger().Debugf("Discovery: Service scan send packet length[%d], buf[%v]", tPacket.Len, tPacket.Buffer)
				logging.Logger().Debugf("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().Debugf("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().Debugf("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().Debugf("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, csm.NewPacket(buf, rn)) {
					// logging.Logger().Debugf("Discovery: Service scan receive match length[%d], buf[%v]", rn, buf)
					logging.Logger().Debugf("Discovery: Service scan[%s] on %s:%d receive match length[%d]", sc.Type(), info.IP(), info.Port(), rn)
					found = true
				} else {
					// logging.Logger().Debugf("Discovery: Service scan receive not match length[%d], buf[%v]", rn, buf)
					logging.Logger().Debugf("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 = &ocdm.Service{
					ServiceName: m.Name(),
					CryptoType:  occc.ToCryptoType(sc.Type()),
				}
				break Loop
			}
		}
	}

	return s
}

func hadlePostPacket(info csm.MatchInfo, sc serviceConnector) *ocdm.Service {
	ms := matcher.GetTCPMatchers(false)
	buf := make([]byte, 1024)
	var s *ocdm.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().Debugf("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().Debugf("Discovery: Service scan send packet length[%d], buf[%v]", tPacket.Len, tPacket.Buffer)
			logging.Logger().Debugf("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().Debugf("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().Debugf("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 = &ocdm.Service{
						ServiceName: m.Name(),
						CryptoType:  occc.ToCryptoType(sc.Type()),
					}
					break
				}

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

			if m.Match(info, j, csm.NewPacket(buf, rn)) {
				if packetCount-1 == j {
					s = &ocdm.Service{
						ServiceName: m.Name(),
						CryptoType:  occc.ToCryptoType(sc.Type()),
					}
					break
				}

				// logging.Logger().Debugf("Discovery: Service scan receive match length[%d], buf[%v]", rn, buf)
				logging.Logger().Debugf("Discovery: Service scan[%s] on %s:%d receive match length[%d]", sc.Type(), info.IP(), info.Port(), rn)
				continue
			} else {
				// logging.Logger().Debugf("Discovery: Service scan receive not match length[%d], buf[%v]", rn, buf)
				logging.Logger().Debugf("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
}