Example #1
0
func (handler *_TunnelClient) Active(context gorpc.Context) error {

	handler.agents = make(map[string]*_Agent)

	handler.system.addTunnel(handler.name, handler, context.Pipeline())

	// send TunnelWhoAmI

	whoAmI := gorpc.NewTunnelWhoAmI()

	whoAmI.Services = handler.system.system.AgentServices()

	var buff bytes.Buffer

	gorpc.WriteTunnelWhoAmI(&buff, whoAmI)

	message := gorpc.NewMessage()

	message.Code = gorpc.CodeTunnelWhoAmI

	message.Content = buff.Bytes()

	context.Send(message)

	return nil
}
Example #2
0
func (handler *_HeartbeatHandler) timeoutLoop(context gorpc.Context, exitflag chan bool) {

	wheel := context.Pipeline().TimeWheel()

	ticker := wheel.NewTicker(handler.timeout)

	defer ticker.Stop()

	for {

		select {
		case <-ticker.C:

			if time.Now().Sub(handler.timestamp) > handler.timeout*2 {
				handler.context.Close()
				handler.W("heartbeat timeout(%s), close current pipeline(%s)", handler.timeout*2, handler.context.Pipeline())
				return
			}

			message := gorpc.NewMessage()

			message.Code = gorpc.CodeHeartbeat

			handler.context.Send(message)

			handler.V("%s send heartbeat message", handler.context.Pipeline())

		case <-exitflag:
			handler.V("exit heartbeat loop .....................")
			return
		}
	}
}
Example #3
0
func (handler *_TunnelClient) Inactive(context gorpc.Context) {
	for _, agent := range handler.agents {
		handler.system.system.UnbindAgent(agent)
	}

	handler.system.removeTunnel(handler.name, handler, context.Pipeline())
}
Example #4
0
File: dh.go Project: gsrpc/gorpc
func (handler *_CryptoClient) Active(context gorpc.Context) error {
	// create whoAmI message

	message := gorpc.NewMessage()

	message.Code = gorpc.CodeWhoAmI

	whoAmI := gorpc.NewWhoAmI()

	whoAmI.ID = handler.device

	whoAmI.Context = []byte(handler.dhKey.Exchange().String())

	var buff bytes.Buffer

	err := gorpc.WriteWhoAmI(&buff, whoAmI)

	if err != nil {
		context.Close()
		return err
	}

	message.Content = buff.Bytes()

	handler.V("send whoAmI handshake")

	context.Send(message)

	return gorpc.ErrSkip

}
Example #5
0
func (handler *_TransProxyHandler) Active(context gorpc.Context) error {

	dh, _ := context.Pipeline().Handler(dhHandler)

	handler.device = dh.(gorpcHandler.CryptoServer).GetDevice()

	return nil
}
Example #6
0
func (client *_Client) Active(context gorpc.Context) error {

	dh, _ := context.Pipeline().Handler(dhHandler)

	device := dh.(handler.CryptoServer).GetDevice()

	client.pipeline = context.Pipeline()

	client.device = device

	client.context.addClient(client)

	return nil
}
Example #7
0
func (handler *_TunnelServerHandler) MessageReceived(context gorpc.Context, message *gorpc.Message) (*gorpc.Message, error) {

	if message.Code == gorpc.CodeTunnelWhoAmI {

		handler.I("tunnel handshake ......")

		whoAmI, err := gorpc.ReadTunnelWhoAmI(bytes.NewBuffer(message.Content))

		if err != nil {
			return nil, err
		}

		handler.proxy.proxy.BindServices(handler.proxy, context.Pipeline(), whoAmI.Services)

		context.FireActive()

		return nil, nil
	}

	if message.Code != gorpc.CodeTunnel {
		return message, nil
	}

	handler.V("backward tunnel message")

	tunnel, err := gorpc.ReadTunnel(bytes.NewBuffer(message.Content))

	if err != nil {
		handler.E("backward tunnel(%s) message -- failed\n%s", tunnel.ID, err)
		return nil, err
	}

	if device, ok := handler.proxy.client(tunnel.ID); ok {

		tunnel.Message.Agent = handler.id

		err := device.SendMessage(tunnel.Message)

		if err == nil {
			handler.V("backward tunnel message -- success")
			return nil, nil
		}

		return nil, err
	}

	handler.E("backward tunnel(%s) message -- failed,device not found", tunnel.ID)

	return nil, nil
}
Example #8
0
func (handler *_HeartbeatHandler) MessageReceived(context gorpc.Context, message *gorpc.Message) (*gorpc.Message, error) {

	if message.Code == gorpc.CodeHeartbeat {

		handler.V("%s recv heartbeat message", context.Pipeline())

		if handler.timeout != 0 {
			handler.timestamp = time.Now()
		}

		return nil, nil
	}

	return message, nil
}
Example #9
0
func newAgent(ctx gorpc.Context, handler *_TunnelClient, device *gorpc.Device) (*_Agent, error) {
	context := &_Agent{
		handler: handler,
		id:      device,
	}

	context.Sink = gorpc.NewSink(device.String(), context, ctx.Pipeline().TimeWheel(), handler.timeout)

	var err error

	err = handler.system.system.BindAgent(context)

	if err != nil {
		return nil, err
	}

	return context, nil
}
Example #10
0
File: state.go Project: gsrpc/gorpc
func (handler *_StateHandler) Inactive(context gorpc.Context) {
	handler.f(context.Pipeline(), gorpc.StateDisconnect)
}
Example #11
0
File: state.go Project: gsrpc/gorpc
func (handler *_StateHandler) Unregister(context gorpc.Context) {
	handler.f(context.Pipeline(), gorpc.StateClosed)
}
Example #12
0
File: state.go Project: gsrpc/gorpc
func (handler *_StateHandler) Active(context gorpc.Context) error {
	handler.f(context.Pipeline(), gorpc.StateConnected)
	return nil
}
Example #13
0
File: dh.go Project: gsrpc/gorpc
func (handler *_CryptoClient) MessageReceived(context gorpc.Context, message *gorpc.Message) (*gorpc.Message, error) {

	if message.Code == gorpc.CodeHeartbeat {
		return message, nil
	}

	if handler.block == nil {

		handler.V("expect handshake accept")

		if message.Code != gorpc.CodeAccept {

			handler.E("unexpect message(%s)", message.Code)

			context.Close()

			return nil, gserrors.Newf(gorpc.ErrRPC, "expect handshake(Accept) but got(%s)", message.Code)
		}

		handler.V("parse handshake accept")

		val, ok := new(big.Int).SetString(string(message.Content), 0)

		if !ok {
			context.Close()
			return nil, gserrors.Newf(gorpc.ErrRPC, "parse Accept#Content as big.Int error")
		}

		key := make([]byte, des.BlockSize)

		keyval := handler.dhKey.Gen(val).Uint64()

		binary.BigEndian.PutUint64(key[:8], keyval)

		handler.V("shared key \n\t%d\n\t%v ", keyval, key)

		block, err := des.NewCipher(key)

		if err != nil {
			context.Close()
			return nil, gserrors.Newf(err, "create new des Cipher error")
		}

		handler.block = block

		handler.V("%s handshake -- success", context.Name())

		context.FireActive()

		for _, message := range handler.cached {
			message, _ = handler.MessageSending(context, message)
			context.Send(message)
		}

		handler.cached = nil

		return nil, nil
	}

	if message.Code == gorpc.CodeHeartbeat {
		return message, nil
	}

	blocksize := handler.block.BlockSize()

	if len(message.Content)%blocksize != 0 {
		context.Close()
		return nil, gserrors.Newf(gorpc.ErrRPC, "%s invalid encrypt data", context)
	}

	blocks := len(message.Content) / blocksize

	for i := 0; i < blocks; i++ {
		offset := i * blocksize
		v := message.Content[offset : offset+blocksize]
		handler.block.Decrypt(v, v)
	}

	message.Content = PKCS5UnPadding(message.Content)

	return message, nil
}
Example #14
0
File: dh.go Project: gsrpc/gorpc
func (handler *_CryptoServer) MessageReceived(context gorpc.Context, message *gorpc.Message) (*gorpc.Message, error) {

	if message.Code == gorpc.CodeHeartbeat {
		return message, nil
	}

	if handler.block == nil {

		handler.V("expect WhoAmI message")
		// expect whoAmI message
		if message.Code != gorpc.CodeWhoAmI {
			context.Close()
			return nil, gserrors.Newf(gorpc.ErrRPC, "expect WhoAmI message but got(%s)", message.Code)
		}

		handler.V("parse WhoAmI message")

		whoAmI, err := gorpc.ReadWhoAmI(bytes.NewBuffer(message.Content))

		if err != nil {
			context.Close()
			return nil, err
		}

		val, ok := new(big.Int).SetString(string(whoAmI.Context), 0)

		if !ok {
			context.Close()
			return nil, gserrors.Newf(gorpc.ErrRPC, "parse WhoAmI#Context as big.Int error")
		}

		dhKey, err := handler.resovler.Resolve(whoAmI.ID)

		if err != nil {
			context.Close()
			return nil, err
		}

		message.Code = gorpc.CodeAccept

		message.Content = []byte(dhKey.Exchange().String())

		context.Send(message)

		key := make([]byte, des.BlockSize)

		keyval := dhKey.Gen(val).Uint64()

		binary.BigEndian.PutUint64(key[:8], keyval)

		handler.V("shared key \n\t%d\n\t%v ", keyval, key)

		block, err := des.NewCipher(key)

		if err != nil {
			context.Close()
			return nil, gserrors.Newf(err, "create new des Cipher error")
		}

		handler.block = block

		handler.device = whoAmI.ID

		context.FireActive()

		for _, message := range handler.cached {
			message, _ = handler.MessageSending(context, message)
			context.Send(message)
		}

		handler.cached = nil

		handler.V("%s handshake -- success", context.Name())

		return nil, nil

	}

	blocksize := handler.block.BlockSize()

	if len(message.Content)%blocksize != 0 {
		context.Close()
		return nil, gserrors.Newf(gorpc.ErrRPC, "invalid encrypt data")
	}

	blocks := len(message.Content) / blocksize

	for i := 0; i < blocks; i++ {
		offset := i * blocksize
		v := message.Content[offset : offset+blocksize]
		handler.block.Decrypt(v, v)
	}

	message.Content = PKCS5UnPadding(message.Content)

	return message, nil
}
Example #15
0
func (handler *_TunnelServerHandler) Inactive(context gorpc.Context) {
	go handler.proxy.proxy.UnbindServices(handler.proxy, context.Pipeline())
}
Example #16
0
func (handler *_TransProxyHandler) MessageReceived(context gorpc.Context, message *gorpc.Message) (*gorpc.Message, error) {

	if message.Code == gorpc.CodeResponse {

		if server, ok := handler.tunnel(message.Agent); ok {

			err := handler.forward(server, message)

			if err != nil {
				context.Close()
			}

			return nil, err
		}

		return message, nil

	}

	if message.Code != gorpc.CodeRequest {

		return message, nil
	}

	request, err := gorpc.ReadRequest(bytes.NewBuffer(message.Content))

	if err != nil {
		handler.E("[%s] unmarshal request error\n%s", handler.proxy.name, err)
		return nil, err
	}

	service := request.Service

	if transproxy, ok := handler.transproxy(service); ok {

		handler.V("forward tunnel(%s) message", handler.device)

		tunnel := gorpc.NewTunnel()

		tunnel.ID = handler.device

		tunnel.Message = message

		var buff bytes.Buffer

		err := gorpc.WriteTunnel(&buff, tunnel)

		if err != nil {
			return nil, err
		}

		message.Code = gorpc.CodeTunnel

		message.Content = buff.Bytes()

		err = transproxy.SendMessage(message)

		if err != nil {
			context.Close()
			handler.V("forward tunnel(%s) message(%p) -- failed\n%s", handler.device, message, err)
			return nil, err
		}

		handler.V("forward tunnel(%s) message(%p) -- success", handler.device, message)

		return nil, err
	}

	return message, nil
}