示例#1
0
文件: udp2tcp.go 项目: zgbkny/gox
/**
 * tunnel call
 **/
func onData(p *udppacket.Packet) int {
	LOG.Println("udp2tcp onData")
	p.LogPacket()
	// close packet
	if p.Length == 0 {
		releaseSession(p.SessionId, false)
		return 1
	}
	s := getSession(p.SessionId)
	if s == nil {
		return -1
	}
	//LOG.Println("udp2tcp check")
	s.Slock.Lock()
	s.ProcessNewPacketFromClientProxy(p)
	for {
		p := s.GetNextRecvDataToSend()
		if p == nil {
			LOG.Println("send data nil")
			break
		}
		processWrite(s, p.GetPacket())

	}
	s.Slock.Unlock()
	return 0
}
示例#2
0
文件: tcp2udp.go 项目: zgbkny/gox
/**
 * tunnel call
 *
 **/
func onData(p *udppacket.Packet) int {
	LOG.Println("tcp2udp onData")
	p.LogPacket()
	// getsession
	s, ok := idSessionMap[p.SessionId]
	if !ok {
		return -1
	}
	if p.Length == 0 {
		releaseSession(s.GetId(), false)
	}
	// processNewPacketFromServerProxy
	s.Slock.Lock()
	s.ProcessNewPacketFromServerProxy(p)
	// getNextDataToSend

	for {
		p := s.GetNextRecvDataToSend()
		if p == nil {
			break
		}
		processWrite(s, p.GetPacket())

	}
	s.Slock.Unlock()
	return 0
}
示例#3
0
func (utAddId *UT_ADD_ID) WriteToClientProxy(p *udppacket.Packet) *udppacket.Packet {
	utAddId.LOG.Print("ut_add_id_module WriteToClientProxy")
	utAddId.lock.Lock()
	defer utAddId.lock.Unlock()
	if p.ModulesCtx[utAddId.Index] == nil {
		p.ModulesCtx[utAddId.Index] = new(CTX_UT_ADD_ID)
		tunnelId := utAddId.Ut.GetNewTunnelId()
		p.ChangeTunnelId(tunnelId)
	}
	return p
}
示例#4
0
文件: udptunnel.go 项目: zgbkny/gox
/**
 * 处理服务器网关写原始数据
 * rawData: 原始数据,但是前面预留了96(ut.Reserved)字节的头空间
 **/
func (ut *UDPTunnel) WritePacketToClientProxy(p *udppacket.Packet) {
	//log.Println("udptunnel WritePacketToClientProxy")
	var sendP *udppacket.Packet = p
	size := len(ut.Handlers)
	for i := 0; i < size; i++ {
		sendP = ut.Handlers[i].WriteToClientProxy(sendP)
		if sendP == nil {
			break
		}
	}
	if sendP != nil {
		ut.send <- sendP.GetPacket()
	}
}
示例#5
0
/***********************************************************
 * 处理发送给tunnel的数据包
 * - 功能:将新数据包加入发送队列,重传的数据包,更新状态
 ***********************************************************/
func (utNack *UT_NACK) processSendPacket(p *udppacket.Packet) {

	/***** SEND *****/
	if wrapper, ok := utNack.SendMap[p.TunnelId]; ok {
		wrapper.p = p
		wrapper.status = WRAPPER_STATUS_RTR
	} else { // 新包,发送队列中不存在该packet的wrapper
		wrapper = new(PACKET_WRAPPER)
		wrapper.p = p
		wrapper.status = WRAPPER_STATUS_SENDED
		utNack.SendMap[p.TunnelId] = wrapper
	}

	if p.TunnelId > utNack.maxSendId {
		utNack.maxSendId = p.TunnelId
	}

	/***** RECV *****/
	otherTunnelId, flag := utNack.getNackPacketTunnelId()
	p.ChangeOtherTunnelId(otherTunnelId)
	p.ChangePacketType(flag)
}
示例#6
0
/*************************************************************
 * 处理从tunnel收到的数据包
 * - 功能:根据包的类型,处理相应的OtherTunnelId的数据包,是还没有到
 * 该数据包,还是需要重传顺便对需要确认的数据包进行确认释放
 ************************************************************/
func (utNack *UT_NACK) processRecvPacket(p *udppacket.Packet) {
	utNack.LOG.Println("processRecvPacket")
	status := p.GetPacketType()
	utNack.LOG.Println("tunnelId", p.TunnelId, "packetType", status)
	/***** SEND *****/
	if status&udppacket.PACK_ACK == udppacket.PACK_ACK {
		utNack.LOG.Println("ack")
		utNack.ackPackets(p.OtherTunnelId)
	}

	/***** RECV *****/
	wrapper, ok := utNack.RecvMap[p.TunnelId]
	if ok {
		wrapper.status = WRAPPER_STATUS_RECVED
	} else {
		wrapper = new(PACKET_WRAPPER)
		wrapper.status = WRAPPER_STATUS_RECVED
	}

	utNack.RecvMap[p.TunnelId] = wrapper
	if p.TunnelId > utNack.maxRecvId {
		utNack.maxRecvId = p.TunnelId
	}
}
示例#7
0
func (utWriter *UT_WRITER) WriteToClientProxy(p *udppacket.Packet) *udppacket.Packet {
	utWriter.Ut.WriteData(p.GetPacket())
	return nil
}