Sybase TDS协议分析

TDS版本比较老,可能与当前版本有所不同。

Sybase与Sql Server部份版本 都采用TDS协议,但包大小等有所不同。

import java.util.LinkedList;

/**
 * TDS协议分析适用于Sybase<br/>
 * TDS版本4.2应用Sybase SQL Server < 10 and Microsoft SQL Server 6.5<br/>
 * TDS版本5.0应用于Sybase SQL Server >= 10
 * @author shanl
 *
 */
public class TDSAnalyForSybase implements SybaseTDSType{
	private LinkedList<byte[]> packageBuffer = new LinkedList<byte[]>();

	/**
	 * 向缓存区插入一个数据包
	 * @param bys
	 * @param offset
	 * @param len
	 * @return true:最后一个包,false:非最后一个数据包
	 */
	public boolean addPackage(byte[] bys, int offset, int len){
		byte[] tmp = new byte[len];
		int lastFlag = bys[1];
		System.arraycopy(bys, offset, tmp, 0, len);
		this.packageBuffer.addLast(tmp);
		return LAST_INDICATOR_LAST_PACKETS==lastFlag;
	}

	/**
	 * 得到并从队列中移除最后一个数据包
	 * @return
	 */
	public byte[] pollPackage(){
		return this.packageBuffer.pollFirst();
	}

	/**
	 * 取(并移除)最后一个数据包
	 * @param bys
	 * @param offset
	 * @return
	 */
	public int getFirstPackage(byte[] bys, int offset){
		byte[] tmp = pollPackage();
		System.arraycopy(tmp, 0, bys, offset, tmp.length);
		return tmp.length;
	}

//		//头8个字节为标志
//		int packageType = bys[offset+0]; 	//0x0f表示TDS5.0 query; 0x02表示TDS 4.2 & 5.0 Login Packet
//		int lastFlag = bys[offset+1];		//最后一个包标志,0x00表示还有更多包,0x01表示是最后一个包
//		int packageSize = Utility.byte2Short(bys, offset+2);	//包他长度
//		byte space0 = bys[offset+4];		//以下4(从当前位置算起)个为0x00
//		byte space1 = bys[offset+5];
//		byte space2 = bys[offset+6];
//		byte space3 = bys[offset+7];
//		//内容
//		byte flag0 = bys[offset+8]; 	//0x21 
//		byte flag1 = bys[offset+9]; 	//0x00
//		byte flag2 = bys[offset+10]; 	//0x00
//		int sqlLen = Utility.byte2Short(bys, offset+11);	//sql长度
//
//		byte[] flag = new byte[3];
//		int packageCount = 0;
//	/**
//	 * 返回sql<br/>
//	 * 建议在测试isLastPackage()后,再执行此语句,否则你拿到的sql可能是不完整的。
//	 * @return 如果数据不完整或没有sql则返回""
//	 */
//	public String getString(){
//		String sql = "";
//		int packageSize = 0;
////		byte[] bys = null;
//
////		for(int i=0,end=size(); i<end; i++){
//		for(byte[] bys: packageBuffer){
//			packageSize = Utility.byte2Short(bys, 2);
//
//			//字节过于少的数据包将被抛弃
//			if(packageSize>=9){
//				if(0x21==bys[8] && 0x00==bys[9] && 0x00==bys[10]){
//					sql += new String(bys, 4+4+3+2, packageSize-(4+4+3+2));
////				}else if(0x01 == bys[1]){
////					sql += new String(bys, 4+4, packageSize-(4+4));
////					break;
//				}else if(0xE6==bys[8] && 0x00==bys[9] && 0x09==bys[10]){
//				}else{
//					sql += new String(bys, 4+4, packageSize-(4+4));
//				}
//
//				bys = null;
//			}
//		}
//
//		return sql;
//	}

	/**
	 * 返回sql语句
	 * @return
	 */
	public String getSql(){
		String sql = "";
		int packageSize = 0;
		byte[] bys = null;
		boolean flagSql = false;
		int sysbaseHeaderSize = 4+4+4+2;

		for(int i=0,end=size(); i<end; i++){
//		for(byte[] bys: packageBuffer){
			bys = this.packageBuffer.get(i);
			packageSize = Utility.byte2Short(bys, 2);

			if(packageSize>=9){
				if(0x0f!=bys[0]){	//连接请求
					break;
				}

//				if(0xe6==bys[8] && 0x00==bys[9] && 0x09==bys[10]){	//不符合sql语句规范
//					break;
//				}

				if(flagSql){
					sql += new String(bys, 4+4, packageSize-(4+4));
					continue;
				}

				if(0x21==bys[8] ){	//符合sql语句规范 //&& 0x00==bys[9] && 0x00==bys[10]
					sql += new String(bys, sysbaseHeaderSize, packageSize-(sysbaseHeaderSize));
					flagSql = true;
				}else{	//不符合sql语句规范
					break;
				}
			}
		}
		reset();

		return sql;
	}

	/**
	 * 返回缓存区的数据包数
	 * @return
	 */
	public int size(){
		return this.packageBuffer.size();
	}

	/**
	 * 缓存区是否为空
	 * @return
	 */
	public boolean isEmpty(){
		return this.packageBuffer.isEmpty();
	}

	/**
	 * 重置数据<br/>
	 * 调用此方法用清空旧数据
	 */
	public void reset(){
		this.packageBuffer.clear();
	}

	/**
	 * 返回最后一次插入的包类型
	 * @return 	0x0f表示TDS5.0 query;<br/> 
	 * 			0x02表示TDS 4.2 & 5.0 Login Packet
	 */
	public int getPackageType(){
		int packageType = packageBuffer.getLast()[0];; 	//0x0f表示TDS5.0 query; 0x02表示TDS 4.2 & 5.0 Login Packet
		return packageType;
	}

//	/**
//	 * 返回最后一次插入的包是否为SQL的最后一个包
//	 * @return 	0:最后一个sql数据包 <br/>
//	 * 			1:非最后一个sql数据包 <br/>
//	 * 			2:非sql数据包 
//	 */
//	public int isSqlLastPackage(){
//		byte[] bys = packageBuffer.getLast();
//		int lastFlag = bys[1];		//最后一个包标志,0x00表示还有更多包,0x01表示是最后一个包
//		int res = 2;
//
//		if(LAST_INDICATOR_LAST_PACKETS==lastFlag){
//			if(0x21==bys[8] && 0x00==bys[9] && 0x00==bys[10]){ 			//sql标志
//				res = 1;
//			}else if(0xE6==bys[8] && 0x00==bys[9] && 0x09==bys[10]){ 	//非sql标志
//				res = 2;
//			}else{
//				res = 0;
//			}
//		}else{
//			res = 2;
//		}
//
//		return res;
//	}

	/**
	 * 返回最后一次插入的包长度
	 * @return 长度>=0
	 */
	public int getPackageLength(){
		return Utility.byte2Short(packageBuffer.getLast(), 2);
	}
}
/**
 * 定义SyBase TDS的各种类型<br/>
 * TDS版本:4.2/5.0<br/>
 * 格式:<br/>
 * INT8, INT8, INT16, 4 bytes <br/>
 * packet type, last packet indicator, 	packet size,unknown(always 0x00)
 * @author shanl
 *
 */
public interface SybaseTDSType {
	/**0x01 TDS 4.2 or 7.0 query*/
	byte PACKAGE_TYPE_QUERY_V42_OR_V70 = 0x01;
	/**0x02 TDS 4.2 or 5.0 login packet*/
	byte PACKAGE_TYPE_LOGIN_V42_OR_V50 = 0x02;
	/** 0x03 RPC*/
	byte PACKAGE_TYPE_RPC = 0x03;
	/**0x04 responses from server*/
	byte PACKAGE_TYPE_RESPONSES_FROM_SERVER = 0x04;
	/**0x06 cancels*/
	byte PACKAGE_TYPE_CANCELS = 0x06;
	/**0x07 Used in Bulk Copy*/
	byte PACKAGE_TYPE_USERD_IN_BULK_COPY = 0x07;
	/**0x0F TDS 5.0 query*/
	byte PACKAGE_TYPE_QUERY_V50 = 0x0f;
	/**0x10 TDS 7.0 login packet*/
	byte PACKAGE_TYPE_LOGIN = 0x10;
	/***0x11 TDS 7.0 authentication packet*/
	byte PACKAGE_TYPE_AUTH = 0x11;
	/**0x12 TDS 8 prelogin packet*/
	byte PACKAGE_TYPE_PRELOGIN = 0x12;

	/**0x00 if more packets*/
	byte LAST_INDICATOR_MORE_PACKETS = 0x00;
	/**0x01 if last packet*/
	byte LAST_INDICATOR_LAST_PACKETS = 0x01;
}
package codedepot.hkproject.net.ACSA.db.sybase.util;

/**
 * 各基础类型与byte之间的转换
 * @author shanl
 *
 */
public class Utility {

	/**
	 * 将short转成byte[2]
	 * @param a
	 * @return
	 */
	public static byte[] short2Byte(short a){
		byte[] b = new byte[2];

		b[0] = (byte) (a >> 8);
		b[1] = (byte) (a);

		return b;
	}

	/**
	 * 将short转成byte[2]
	 * @param a
	 * @param b
	 * @param offset b中的偏移量
	 */
	public static void short2Byte(short a, byte[] b, int offset){
		b[offset] = (byte) (a >> 8);
		b[offset+1] = (byte) (a);
	}

	/**
	 * 将byte[2]转换成short
	 * @param b
	 * @return
	 */
	public static short byte2Short(byte[] b){
		return (short) (((b[0] & 0xff) << 8) | (b[1] & 0xff));
	}

	/**
	 * 将byte[2]转换成short
	 * @param b
	 * @param offset
	 * @return 
	 */
	public static short byte2Short(byte[] b, int offset){
		return (short) (((b[offset] & 0xff) << 8) | (b[offset+1] & 0xff));
	}

	/**
	 * long转byte[8]
	 * 
	 * @param a
	 * @param b
	 * @param offset
	 *            b的偏移量
	 */
	public static void long2Byte(long a, byte[] b, int offset) {
		b[offset + 0] = (byte) (a >> 56);
		b[offset + 1] = (byte) (a >> 48);
		b[offset + 2] = (byte) (a >> 40);
		b[offset + 3] = (byte) (a >> 32);

		b[offset + 4] = (byte) (a >> 24);
		b[offset + 5] = (byte) (a >> 16);
		b[offset + 6] = (byte) (a >> 8);
		b[offset + 7] = (byte) (a);
	}

	/**
	 * byte[8]转long
	 * 
	 * @param b
	 * @param offset
	 *            b的偏移量
	 * @return
	 */
	public static long byte2Long(byte[] b, int offset) {
		 return ((((long) b[offset + 0] & 0xff) << 56)
		 | (((long) b[offset + 1] & 0xff) << 48)
		 | (((long) b[offset + 2] & 0xff) << 40)
		 | (((long) b[offset + 3] & 0xff) << 32)
		 
		 | (((long) b[offset + 4] & 0xff) << 24)
		 | (((long) b[offset + 5] & 0xff) << 16)
		 | (((long) b[offset + 6] & 0xff) << 8)
		 | (((long) b[offset + 7] & 0xff) << 0));
	}

	/**
	 * byte[8]转long
	 * 
	 * @param b
	 * @return
	 */
	public static long byte2Long(byte[] b) {
		 return
		 ((b[0]&0xff)<<56)|
		 ((b[1]&0xff)<<48)|
		 ((b[2]&0xff)<<40)|
		 ((b[3]&0xff)<<32)|

		 ((b[4]&0xff)<<24)|
		 ((b[5]&0xff)<<16)|
		 ((b[6]&0xff)<<8)|
		 (b[7]&0xff);
	}

	/**
	 * long转byte[8]
	 * 
	 * @param a
	 * @return
	 */
	public static byte[] long2Byte(long a) {
		byte[] b = new byte[4 * 2];

		b[0] = (byte) (a >> 56);
		b[1] = (byte) (a >> 48);
		b[2] = (byte) (a >> 40);
		b[3] = (byte) (a >> 32);

		b[4] = (byte) (a >> 24);
		b[5] = (byte) (a >> 16);
		b[6] = (byte) (a >> 8);
		b[7] = (byte) (a >> 0);

		return b;
	}

	/**
	 * byte数组转int
	 * 
	 * @param b
	 * @return
	 */
	public static int byte2Int(byte[] b) {
		return ((b[0] & 0xff) << 24) | ((b[1] & 0xff) << 16)
				| ((b[2] & 0xff) << 8) | (b[3] & 0xff);
	}

	/**
	 * byte数组转int
	 * 
	 * @param b
	 * @param offset
	 * @return
	 */
	public static int byte2Int(byte[] b, int offset) {
		return ((b[offset++] & 0xff) << 24) | ((b[offset++] & 0xff) << 16)
				| ((b[offset++] & 0xff) << 8) | (b[offset++] & 0xff);
	}

	/**
	 * int转byte数组
	 * 
	 * @param a
	 * @return
	 */
	public static byte[] int2Byte(int a) {
		byte[] b = new byte[4];
		b[0] = (byte) (a >> 24);
		b[1] = (byte) (a >> 16);
		b[2] = (byte) (a >> 8);
		b[3] = (byte) (a);

		return b;
	}

	/**
	 * int转byte数组
	 * 
	 * @param a
	 * @param b
	 * @param offset
	 * @return
	 */
	public static void int2Byte(int a, byte[] b, int offset) {
		b[offset++] = (byte) (a >> 24);
		b[offset++] = (byte) (a >> 16);
		b[offset++] = (byte) (a >> 8);
		b[offset++] = (byte) (a);
	}
}

测试代码:

TDSAnalyForSybase sySybase = new TDSAnalyForSybase();
byte[] buff = new byte[1024 * 4];
int ret_read = 0;

//....
ret_read = sybaseIn.read(buff);

if (sySybase.addPackage(buff, 0, ret_read)) {  //最后一个包
	System.out.println(sySybase.getSql());
}else{ //非最后一个包,继续读
//...
}
//....
时间: 2024-10-08 04:11:26

Sybase TDS协议分析的相关文章

蓝牙协议分析(7)_BLE连接有关的技术分析

转自:http://www.wowotech.net/bluetooth/ble_connection.html#comments 1. 前言 了解蓝牙的人都知道,在经典蓝牙中,保持连接(Connection)是一个相当消耗资源(power和带宽)的过程.特别是当没有数据传输的时候,所消耗的资源完全被浪费了.因而,对很多蓝牙设备来说(特别是功耗敏感的设备),希望在无数可传的时候,能够断开连接.但是,由于跳频(hopping)以及物理通道(Physical Channel)划分的缘故,经典蓝牙连接

BT协议分析(1)&mdash;1.0协议

简述 BT下载是采用P2P的下载方式,下载的大致形式采用如下图所示,处于图示中心的称为Tracker服务器,其余称为Peer.   缺点 1.资源的安全性 2.资源的实效性(没有上传者则BT也将失效) 3.版权 协议分析 对BT协议(1.0)的分析主要包含4个部分: 1.种子文件的分析 2.同Tracker服务器的通讯(采用HTTP协议) 3.同其他peer(配合/协同者)的通讯(采用TCP协议) 4.总结 分析前的了解 在这些分析之前,需要先了解两点BT协议采用的基础: 1.BT协议中采用的单

物联网MQTT协议分析和开源Mosquitto部署验证

在<物联网核心协议—消息推送技术演进>一文中已向读者介绍了多种消息推送技术的情况,包括HTTP单向通信.Ajax轮询.Websocket.MQTT.CoAP等,其中MQTT协议为IBM制定并力推,其具有开放.简单.轻量级以及易于实现的特点使得其即便在资源受限的环境中也能得到很好的使用,比如运行在资源紧缺型的嵌入式系统中或网络带宽非常昂贵的环境中,除此之外,它也被广泛用于遥感勘测.智能家居.能源监测和医疗应用程序等各个领域,是物联网的重要组成部分,将来可能会成为物联网的事实标准. 本篇文章将帮助

协议分析 - DHCP协议解码详解

协议分析 - DHCP协议解码详解 [DHCP协议简介] DHCP,全称是 Dynamic Host Configuration Protocol﹐中文名为动态主机配置协议,它的前身是 BOOTP,它工作在OSI的应用层,是一种帮助计算机从指定的DHCP服务器获取它们的配置信息的自举协议. DHCP使用客户端/服务器模式,请求配置信息的计算机叫做DHCP客户端,而提供信息的叫做DHCP的服务器.DHCP为客户端分配地址的方法有三种:手工配置.自动配置.动态配置. DHCP最重要的功能就是动态分配

linux 网络协议分析---3

本章节主要介绍linxu网络模型.以及常用的网络协议分析以太网协议.IP协议.TCP协议.UDP协议 一.网络模型 TCP/IP分层模型的四个协议层分别完成以下的功能: 第一层 网络接口层 网络接口层包括用于协作IP数据在已有网络介质上传输的协议.实际上TCP/IP标准并不定义与ISO数据链路层和物理层相对应的功能.相反,它定义像 地址解析协议(Address Resolution Protocol,ARP)这样的协议,提供TCP/IP协议的数据结构和实际物理硬件之间的接口. 第二层 网间层 网

网络协议分析

1. 网络模型 2. 协议分析 2.1协议架构 2. 2 以太网协议格式 2. 3 IP协议格式 2. 4 TCP协议格式 2. 5 UDP协议格式

http-live-streaming 协议分析

http-live-streaming 协议分析:不受限制的多媒体数据流的传输.协议支持媒体数据加密与流切换(例如不同码率).媒体数据创建后立即传输,播放接近实时.媒体数据通常采用HTTP进行传输.播放列表由一个有序的媒体URI列表和信息标签组成,每个媒体URI指向一个媒体文件,这个媒体文件是单个连续媒体流上的一个片断.为了播放媒体流,客户端首先获取播放列表文件,然后获取并播放播放列表中的每个媒体流文件.客户端依据下文定义方式重复加载播放列表文件以获取追加片断.播放列表必须是扩展的M3U播放列表

QQ2010协议分析系列(二) - 登录之第一篇(0x0091)

QQ2010协议分析第一篇 测试QQ:597789809 昵称:浪子无情 尝试QQ服务器IP:112.95.240.125 client IP:222.35.174.5(我的外网IP) 密码:这个算了吧 Send: 看到下面的数字很迷茫吧,不用着急,我慢慢解释 下面的文本是HEX字符串,是常用网络16进制文本方式. QQ常用消息包结构: 包头:02 //表示包的开头 1F 57 //QQ版本代码,这里表示QQ2010sp3版本 00 91 //包命令 58 16      //这个不是固定的,表

usb协议分析-设备描述符配置包-描述符

/* usb协议分析仅供大家参考---设备描述符配置包,设备描述符, 地址设置, 配置描述符, 字符串描述符 */ /* -1- usb设备描述符配置包 */ typedef struct _USB_SETUP_PACKET { REQUEST_TYPE bmRequestType; BYTE bRequest; WORD_BYTE wValue; WORD_BYTE wIndex; WORD wLength; } USB_SETUP_PACKET; 1.bmRequestType 是包含有下面