php pack、unpack、ord 函数使用方法

2014-03-21 17:49 youxin 阅读(2425) 评论(0) 编辑收藏举报

string pack ( string $format [, mixed $args [, mixed $... ]] )

Pack given arguments into a binary string according to format.

The idea for this function was taken from Perl and all formatting codes work the same as in Perl. However, there are some formatting codes that are missing such as Perl's "u" format code.

Note that the distinction between signed and unsigned values only affects the function unpack(), where as function pack()gives the same result for signed and unsigned format codes.

参数描述
format 必需。规定在包装数据时所使用的格式。
args+ 可选。规定被包装的一个或多个参数。

The format string consists of format codes followed by an optional repeater argument. The repeater argument can be either an integer value or * for repeating to the end of the input data. For a, A, h, H the repeat count specifies how many characters of one data argument are taken, for @ it is the absolute position where to put the next data, for everything else the repeat count specifies how many data arguments are consumed and packed into the resulting binary string.

Currently implemented formats are:

http://www.php.net/manual/zh/function.pack.php

字符说明
a 将字符串空白以 NULL 字符填满
A 将字符串空白以 SPACE 字符 (空格) 填满
h 十六进位字符串，低位在前
H 十六进位字符串，高位在前
c 有号字符
C 无号字符
s 有号短整数 (十六位，依计算机的位顺序)
S 无号短整数 (十六位，依计算机的位顺序)
n 无号短整数 (十六位, 高位在后的顺序)
v 无号短整数 (十六位, 低位在后的顺序)
i 有号整数 (依计算机的顺序及范围)
I 无号整数 (依计算机的顺序及范围)
l 有号长整数 (卅（释义:30)二位，依计算机的位顺序)
L 无号长整数 (卅二位，依计算机的位顺序)
N 无号短整数 (卅二位, 高位在后的顺序)
V 无号短整数 (卅二位, 低位在后的顺序)
f 单精确浮点数 (依计算机的范围)
d 倍精确浮点数 (依计算机的范围)
x 空位
X 倒回一位
@ 填入 NULL 字符到绝对位置

php文档：http://php.net/manual/zh/function.pack.php

pack() format characters
Code	Description
a	NUL-padded string
A	SPACE-padded string
h	Hex string, low nibble first
H	Hex string, high nibble first
c	signed char
C	unsigned char
s	signed short (always 16 bit, machine byte order)
S	unsigned short (always 16 bit, machine byte order)
n	unsigned short (always 16 bit, big endian byte order)
v	unsigned short (always 16 bit, little endian byte order)
i	signed integer (machine dependent size and byte order)
I	unsigned integer (machine dependent size and byte order)
l	signed long (always 32 bit, machine byte order)
L	unsigned long (always 32 bit, machine byte order)
N	unsigned long (always 32 bit, big endian byte order)
V	unsigned long (always 32 bit, little endian byte order)
q	signed long long (always 64 bit, machine byte order)
Q	unsigned long long (always 64 bit, machine byte order)
J	unsigned long long (always 64 bit, big endian byte order)
P	unsigned long long (always 64 bit, little endian byte order)
f	float (machine dependent size and representation)
d	double (machine dependent size and representation)
x	NUL byte
X	Back up one byte
Z	NUL-padded string (new in PHP 5.5)
@	NUL-fill to absolute position

args

<?php
$binarydata = pack("nvc*", 0x1234, 0x5678, 65, 66);
?>

The resulting binary string will be 6 bytes long and contain the byte sequence 0x12, 0x34, 0x78, 0x56, 0x41, 0x42.

unpack函数说明：本函数用来将位的字符串的资料解压缩

语法：unpack(format,args+)

参数描述
format 必需。规定在包装数据时所使用的格式。
args+ 可选。规定被包装的一个或多个参数。

参数与pack相同。

ord函数(ord函数：为序数函数，函数返回值为字符在ASCII码中的序号。)说明：返回对应字符的acill码值

语法：ord($character);

//A字符 
$str = (pack ( "A*", "中国" ));
echo $str, "=", strlen ( $str ), "字节\n";
getAscill ( $str );
echo '<br/>';

//H字符 
$str = (pack ( "H*", "fffe" ));
echo $str, "=", strlen ( $str ), "字节\n";
getAscill ( $str );
echo '<br/>';

//C字符 
$str = (pack ( "C*", "55", "56", "57" ));
echo $str, "=", strlen ( $str ), "字节\n";
getAscill ( $str );
echo '<br/>';

//i字符 短整形 32位 4个字节 64位8个字节 
$str = (pack ( "i", "100" ));
echo $str, "=", strlen ( $str ), "字节\n";
getAscill ( $str );
echo '<br/>';

//s字符 短整形 2个字节 
$str = (pack ( "s", "100" ));
echo $str, "=", strlen ( $str ), "字节\n";
getAscill ( $str );
echo '<br/>';

//l字符 长整形 4个字节 
$str = (pack ( "l", "100" ));
echo $str, "=", strlen ( $str ), "字节\n";
getAscill ( $str );
echo '<br/>';

//f字符 单精度浮点 4个字节 
$str = (pack ( "f", "100" ));
echo $str, "=", strlen ( $str ), "字节\n";
getAscill ( $str );
echo '<br/>';

//d字符 双精度浮点 8个字节 
$str = (pack ( "d", "100" ));
echo $str, "=", strlen ( $str ), "字节\n";
getAscill ( $str );
echo '<br/>';

function getAscill($str) {
    $arr = str_split ( $str );
    foreach ( $arr as $v ) {
        echo $v, "=", ord ( $v ), "\n";
    }
    echo "=============\r\n\r\n";
}

string

 '4xVAB' (length=6)

ä¸å›½=6å—èŠ‚ ä=228 ¸=184 =173 å=229 ›=155 ½=189 =============
ä¸å›½=6å—èŠ‚ ä=228 ¸=184 =173 å=229 ›=155 ½=189 =============
ÿþ=2å—èŠ‚ ÿ=255 þ=254 =============
789=3å—èŠ‚ 7=55 8=56 9=57 =============
d=4å—èŠ‚ d=100 =0 =0 =0 =============
d=2å—èŠ‚ d=100 =0 =============
d=4å—èŠ‚ d=100 =0 =0 =0 =============
ÈB=4å—èŠ‚ =0 =0 È=200 B=66 =============
Y@=8å—èŠ‚ =0 =0 =0 =0 =0 =0 Y=89 @=64 =============

通过上面实例，我们可以看到，相同字符串，用不同格式存储，所占用的字节数不同。这里也可以看到，以不同格式保存字符可以达存储节省空间。而且启到不可读加密效果。突然想到一点，设计数据库字段类型问题，如果一个字段只是：10位长度整型。我们设置为整形：256*256*256*256 就4个字节，如果设置为10个长度字符串。那就占10个字节。整个消化空间就是2倍的。设置正确字符类型对提高数据库性能有很多帮助。呵呵，有点跑题了……

php处理字节码通讯实例分析
刚刚说的pack作用：节省空间、加密格式

下面就这2个做一个实例说明，接口开发要求：

参数描述
用户名 20字节，字符型
密码 10字节，字符型
年龄 1字节，无符char型
出生年月 4字节，整型（19800101）
邮箱 50字节，字符串
各字段间用："\0"分割
A、PACK封包

 
$code=array( 

"username"=>array("A20","张三adfb12"), 

"pass"=>array("A10","asdf*#1"), 

"age"=>array("C","23"), 

"birthday"=>array("I","19900101"), 

"email"=>array("A50","zhangsan@163.com")); 

$stream=join("\0",packByArr($code)); 

echo $stream,strlen($stream); 

 


file_put_contents("c:/1.txt",$stream);    //将流保存起来便于下面读取 

 

function packByArr($arr)  { 

         $atArr=array(); 

         foreach ($arr as $k=>$v) { 

                  $atArr[]=pack($v[0],$v[1]); 

         } 

         return $atArr; 

} 

function getAscill($str) { 

         $arr=str_split($str); 

         foreach ($arr as $v) { 

                  echo $v,"=",ord($v),"\n"; 

         } 

}

(在浏览器中用utf8编码查看：张三adfb12 asdf*#1 Ŧ/zhangsan@163.com 89; 文件内容：

张三adfb12 asdf*#1 Ŧ/ zhangsan@163.com )

因为用”\0”分割，整个长度是89字节。通过上面输出，有一些字符串输出是可以读取的，其它都已经变成乱码了。这也是我说可以保密效果原因。

B、Unpack解包
解包需要按照，打包方式读取，该读取多长，该用什么类型读取，必须与打包规定一样。

<?php
$code=array( 

"username"=>array("A20"), 

"pass"=>array("A10"), 

"age"=>array("C"), 

"birthday"=>array("I"), 

"email"=>array("A50")); 
$stream=file_get_contents("C:/1.txt");
var_dump(unpackByArr($stream,$code));

function unpackByArr($str,$code)
{
    $arr=explode("\0",$str);
    $atArr=array();
    $i=0;
    foreach($code as $k=>$v)
    {
        $atArr[$k]=unpack($v[0],$arr[$i]);
        $i++;
    }
    return $atArr;
}

参考：http://randomclan.blog.163.com/blog/static/1453009820125454418912/

-------------------------------------------------------

案例一、pack实现缩减文件数据存储大小

[php] view plain copy

<?php
//存储整数1234567890
file_put_contents("test.txt", 1234567890);

此时test.txt的文件大小是10byte。注意此时文件大小是10字节，实际占用空间大小是1KB 。

上面存储的整数实际是以字符串形式存储于文件test.txt中。

但如果以整数的二进制字符串存jy储，将会缩减至4byte。

<?php
print_r(unpack("i", file_get_contents("test.txt")));

案例二、数据加密

以字符串形式存储一段有意义数据，7-110-abcdefg-117。

字符"-"分割后，第一位表示字符串长度，第二位表示存储位置，第三位表示实际存储的字符串，第四位表示结尾位置。

[php] view plain copy

<?php
file_put_contents("test.txt", "7-110-abcdefg-117");

上述方法缺点：

一、数据存储大小

二、数据以明文方式存储，如果是任何敏感信息，都可能造成不安全访问。

三、文件存储大小，以不规则方式递增。

加密：

[php] view plain copy

<?php
file_put_contents("test.txt", pack("i2a7i1", 7, 110, "abcdefg", 117));

存储一段数据，加密格式为：整数2位长度字符串10位长度整数1位长度。

优点：

一、数据大小最优化

二、在不知道"i2a7i1"这样的压缩格式时，即使拿到文件，也无法正确读出二进制文件转化为明文。

三、数据增加时，文件存储大小是等量递增。每次都是以19byte递增。

案例三、key-value型文件存储

存储生成的文件为两个：索引文件，数据文件

文件中数据存储的格式如下图：

<?php
error_reporting(E_ALL);

class fileCacheException extends Exception{

}

//Key-Value型文件存储
class fileCache{
     private $_file_header_size = 14;
     private $_file_index_name;
     private $_file_data_name;
     private $_file_index;//索引文件句柄
     private $_file_data;//数据文件句柄
     private $_node_struct;//索引结点结构体
     private $_inx_node_size = 36;//索引结点大小

     public function __construct($file_index="filecache_index.dat", $file_data="filecache_data.dat"){
          $this->_node_struct = array(
               'next'=>array(1, 'V'),
               'prev'=>array(1, 'V'),
              'data_offset'=>array(1,'V'),//数据存储起始位置
              'data_size'=>array(1,'V'),//数据长度
              'ref_count'=>array(1,'V'),//引用此处，模仿PHP的引用计数销毁模式
              'key'=>array(16,'H*'),//存储KEY
          );

          $this->_file_index_name = $file_index;
          $this->_file_data_name = $file_data;

          if(!file_exists($this->_file_index_name)){
               $this->_create_index();
          }else{
               $this->_file_index = fopen($this->_file_index_name, "rb+");
          }

          if(!file_exists($this->_file_data_name)){
               $this->_create_data();
          }else{
               $this->_file_data = fopen($this->_file_data_name, "rb+");//二进制存储需要使用b
          }
     }

     //创建索引文件
     private function _create_index(){
          $this->_file_index = fopen($this->_file_index_name, "wb+");//二进制存储需要使用b
          if(!$this->_file_index) 
               throw new fileCacheException("Could't open index file:".$this->_file_index_name);

          $this->_index_puts(0, '<'.'?php exit()?'.'>');//定位文件流至起始位置0, 放置php标记防止下载
          $this->_index_puts($this->_file_header_size, pack("V1", 0));
     }


     //创建存储文件
     private function _create_data(){
          $this->_file_data = fopen($this->_file_data_name, "wb+");//二进制存储需要使用b
          if(!$this->_file_index) 
               throw new fileCacheException("Could't open index file:".$this->_file_data_name);

          $this->_data_puts(0, '<'.'?php exit()?'.'>');//定位文件流至起始位置0, 放置php标记防止下载
     }

     private function _index_puts($offset, $data, $length=false){
          fseek($this->_file_index, $offset);

          if($length)
          fputs($this->_file_index, $data, $length);
          else
          fputs($this->_file_index, $data);
     }

     private function _data_puts($offset, $data, $length=false){
          fseek($this->_file_data, $offset);
          if($length)
          fputs($this->_file_data, $data, $length);
          else
          fputs($this->_file_data, $data);
     }

     /**
     * 文件锁
     * @param $is_block 是否独占、阻塞锁
     */
     private function _lock($file_res, $is_block=true){
          flock($file_res, $is_block ? LOCK_EX : LOCK_EX|LOCK_NB);
     }

     private function _unlock($file_res){
          flock($file_res, LOCK_UN);
     }

     public function add($key, $value){
          $key = md5($key);
          $value = serialize($value);
          $this->_lock($this->_file_index, true);
          $this->_lock($this->_file_data, true);

          fseek($this->_file_index, $this->_file_header_size);

          list(, $index_count) = unpack('V1', fread($this->_file_index, 4));

          $data_size = filesize($this->_file_data_name);

          fseek($this->_file_data, $data_size);

          $value_size = strlen($value);

          $this->_data_puts(filesize($this->_file_data_name), $value);

          $node_data = 
          pack("V1V1V1V1V1H32", ($index_count==0) ? 0 : $index_count*$this->_inx_node_size, 0, filesize($this->_file_data_name), strlen($value), 0, $key);

          $index_count++;

          $this->_index_puts($this->_file_header_size, $index_count, 4);

          $this->_index_puts($this->get_new_node_pos($index_count), $node_data);

          $this->_unlock($this->_file_data);
          $this->_unlock($this->_file_index);
     }

     public function get_new_node_pos($index_count){
          return $this->_file_header_size + 4 + $this->_inx_node_size * ($index_count-1);
     }

     public function get_node($key){
          $key = md5($key);
          fseek($this->_file_index, $this->_file_header_size);
          $index_count = fread($this->_file_index, 4);

          if($index_count>0) {
               for ($i=0; $i < $index_count ; $i++) { 
                    fseek($this->_file_index, $this->_file_header_size + 4 + $this->_inx_node_size * $i);
                    $data = fread($this->_file_index, $this->_inx_node_size);
                    $node = unpack("V1next/V1prev/V1data_offset/V1data_size/V1ref_count/H32key", $data);

                    if($key == $node['key']){
                         return $node;
                    }
               }
          }else{
               return null;
          }
     }

     public function get_data($offset, $length){
          fseek($this->_file_data, $offset);
          return unserialize(fread($this->_file_data, $length));
     }
}

//使用方法
$cache = new fileCache();
$cache->add('abcdefg' , 'testabc');
$data = $cache->get_node('abcdefg');
print_r($data);
echo $cache->get_data($data['data_offset'], $data['data_size']);

View Code

案例四、socket通信加密

通信双方都定义好加密格式:

例如：

$LOGIN = array(
     'COMMAND'=>array('a30', 'LOGIN'),
     'DATA'=>array('a30', 'HELLO')
);

$LOGOUT = array(
     'COMMAND'=>array('a30', 'LOGOUT'),
     'DATA'=>array('a30', 'GOOD BYE')
);

$LOGIN_SUCCESS = array(
     'COMMAND'=>array('a30', 'LOGIN_SUCCESS'),
     'DATA'=>array('V1', 1)
);

$LOGOUT_SUCCESS = array(
     'COMMAND'=>array('a30', 'LOGIN_SUCCESS'),
     'DATA'=>array('V1', time())
);

服务器端与客户端根据解析COMMAND格式，找到对应的DATA解码方式，得到正确的数据.

转自：http://blog.csdn.net/a600423444/article/details/8653827

详细：

http://my.oschina.net/goal/blog/195749

http://my.oschina.net/goal/blog/202378?p={{currentPage-1}}

一篇文章：

socket字节流解析(网络抓包解析)

研究了一下PHP和C++socket通讯,用C++作为服务器端,php作为客户端进行.

socket通讯是基于协议的,因此,只要双方协议一致就行.

关于协议的选择:我看过网上大部分协议都是在应用层的协议,选用这样的协议很方便,基本上就是字符串传过来,传过去

本次研究的协议算是当今国际化的一个标准做法.length+flag+body(长度+类型+内容)的方式,

total_length	code	flag	length1	string1	length2	string2
总长度	操作类型	标志	字符串1长度	字符串1	字符串2长度	字符串2
4字节	2字节	4字节(暂时无用)	2字节	x字节	2字节	x字节

php实现方式,也很容易,通过pack打包成二进制进行通讯.下面贴一下代码

本地测试主要应用为:发送账号和密码给服务器端

<?php
class Byte{
    //长度
    private $length=0;
    
    private $byte='';
    //操作码
    private $code;
    public function setBytePrev($content){
        $this->byte=$content.$this->byte;
    }
    public function getByte(){
        return $this->byte;
    }
    public function getLength(){
        return $this->length;
    }
    public function writeChar($string){
        $this->length+=strlen($string);
        $str=array_map('ord',str_split($string));
        foreach($str as $vo){
            $this->byte.=pack('c',$vo);
        }
        $this->byte.=pack('c','0');
        $this->length++;
    }
    public function writeInt($str){
        $this->length+=4;
        $this->byte.=pack('L',$str);
    }
    public function writeShortInt($interge){
        $this->length+=2;
        $this->byte.=pack('v',$interge);
    }
}
class GameSocket{
    private $socket;
    private $port=9991;
    private $host='192.168.211.231';
    private $byte;
    private $code;
    const CODE_LENGTH=2;
    const FLAG_LENGTH=4;
    public function __set($name,$value){
        $this->$name=$value;
    }
    public function __construct($host='192.168.211.231',$port=9991){
        $this->host=$host;
        $this->port=$port;
        $this->socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
        if(!$this->socket){
            exit('创建socket失败');
        }
        $result = socket_connect($this->socket,$this->host,$this->port);
        if(!$result){
            exit('连接不上目标主机'.$this->host);
        }
        $this->byte=new Byte();
    }
    public function write($data){
        if(is_string($data)||is_int($data)||is_float($data)){
            $data[]=$data;
        }
        if(is_array($data)){
            foreach($data as $vo){
                $this->byte->writeShortInt(strlen($vo));
                $this->byte->writeChar($vo);
            }
        }
        $this->setPrev();
        $this->send();
    }
    /*
     *设置表头部分
     *表头=length+code+flag
     *length是总长度(4字节)  code操作标志(2字节)  flag暂时无用(4字节)
     */
    private function getHeader(){
        $length=$this->byte->getLength();
        $length=intval($length)+self::CODE_LENGTH+self::FLAG_LENGTH;
        return pack('L',$length);
    }
    private function getCode(){
        return pack('v',$this->code);
    }
    private function getFlag(){
        return pack('L',24);
    }
    
    private function setPrev(){
        $this->byte->setBytePrev($this->getHeader().$this->getCode().$this->getFlag());
    }

    private function send(){
        $result=socket_write($this->socket,$this->byte->getByte());
        if(!$result){
            exit('发送信息失败');
        }
    }
    public function __desctruct(){
        socket_close($this->socket);
    }
}

$data[]='testzouhao';
$data[]='a';
$gameSocket=new GameSocket();
$gameSocket->code=11;
$gameSocket->write($data);

通过抓包分析,得到本次的包内容

包头等等都不用看了,主要看蓝色部分.

根据协议分析,前4个字节为表头,代表的是长度

因此:

17 00 00 00代表的是表头长度,17为16进制,转换为十进制为23,代表其余部分全部加为23字节.

0b 00代表的是操作码为11,代表是登录操作

18 00 00 00代表的是flag,暂时无用,不去理会

0a 00 代表的字符串1的长度,转为十进制为10

74 65 73 74 7a 6f 75 68 61 6f 分别转为十进制之后,是ascii码对应的字符,结果为:testzouhao,

由于C++字符串的机制是末尾是\0,所以在字符串后,00字节就是\0

然后是第二个字符串长度为01 00,也就是为1

61同理,十进制转ascii码,为a,之后的00为c++机制的\0

完美解析,发送包无措,之后c++服务器也返回了相应的包,我在按照同理进行解包就可以了!。

转自：http://blog.csdn.net/cws1214/article/details/9956655

php通过pack和unpack函数实现对二进制数据封装及解析

1. pack和unpack格式字符串解析:a一个填充空的字节串 A一个填充空格的字节串 b一个位串，在每个字节里位的顺序都是升序 B一个位串，在每个字节里位的顺序都是降序 c一个有符号char（8位整数）值 C一个无符号char（8位整数）值；...

1. pack和unpack格式字符串解析:

a一个填充空的字节串

A一个填充空格的字节串

b一个位串，在每个字节里位的顺序都是升序

B一个位串，在每个字节里位的顺序都是降序

c一个有符号char（8位整数）值

C一个无符号char（8位整数）值；关于Unicode参阅U

d本机格式的双精度浮点数

f本机格式的单精度浮点数

h一个十六进制串，低四位在前

H一个十六进制串，高四位在前

i一个有符号整数值，本机格式

I一个无符号整数值，本机格式

l一个有符号长整形，总是32位

L一个无符号长整形，总是32位

n一个16位短整形，“网络”字节序（大头在前）

N一个32位短整形，“网络”字节序（大头在前）

p一个指向空结尾的字串的指针

P一个指向定长字串的指针

q一个有符号四倍（64位整数）值

Q一个无符号四倍（64位整数）值

s一个有符号短整数值，总是16位

S一个无符号短整数值，总是16位，字节序跟机器芯片有关

u一个无编码的字串

U一个Unicode字符数字

v一个“VAX”字节序（小头在前）的16位短整数

V一个“VAX”字节序（小头在前）的32位短整数

w一个BER压缩的整数

x一个空字节（向前忽略一个字节）

X备份一个字节

Z一个空结束的（和空填充的）字节串

规则：

(1).每个字母后面都可以跟着一个数字，表示count（计数，如果count是一个*表示剩下的所有东西。

(2)如果你提供的参数比$format要求的少，pack假设缺的都是空值。如果你提供的参数比$format要求的多，那么多余的参数被忽略。

2.php通过socket和java server通信

php跟java进行socket通讯的时候,php发送一段数据给java,(协议自定,这里假定类型10表示获取游戏邮件列表,10000表示获取的id)

1	`socket_write($sock,pack('CN',10,10000),5);`

java接受到后,会返回一段数据,从中获得你所需要的,比如java先告诉你返回内容规则如下:1 byte,2 int

php可以通过如下方式获得:

1	`$arr=unpack('Csuccess/Nid/Ncount',$data);`

这样就完成一次解析过程.

这里我们都没有提到字符串的发送，我们知道字符串在字节流里的存储方式是前2个字节表示字符串的长度，后面表示字符串的具体内容(学过java的应该都了解),2个字节也就限制了发送长度最大为65536,因而我们要发送字符串需要如下(以下举例都在utf8下完成):

function pack_str($str){
    //如果是gbk,要转成utf8
    // $str = iconv('gbk','utf-8',$str);
  $utflen = strlen($str);
  if ($utflen > 65535) die('too long');
  $in .= pack('C2',$utflen>>8,$utflen>>0);
  return $in.$str;
}

比如我们要向游戏服务器内发送一个公告:各位，服务器在1小时内重起!假设java要求这样的格式:协议号:int,标题,内容。我们就可以如下发送:

$in=pack('N',1000);
$in.=pack_utf8('公告');
$in.=pack_utf8('各位，服务器在1小时内重起!');

这样就完成一次发送.同样如果我们需要读取游戏服务器的数据，比如用户资料,也会返回字符串,原理同上，先读2个字节获取长度，再根据长度来获取具体的内容,代码如下:

$crt_str  =unpack("C{$crt_str_len}str",$data);
      for($ii=1;$ii<=$crt_str_len;$ii++){
       $str .= chr($crt_str['str'.$ii]);
  }

$str就是我们要获取的中文,但是这样极其烦琐，如果有多个字符串的话，中间又包含了其他数据,比如返回为int,string,int,byte,string这样处理起来相当不便,于是提供下面的函数供大家参考:

<?php
/*
由于我的程序经常跟java通信，所以此函数所使用的参数是用java里面的类型来填充的，并且只替换了经常用到的3个类型
C-->b(byte)
n-->s(short)
i-->N(int)
如不习惯或或觉得参数过少，请自行修改
*/                                                                                                                                 
  function rs_unpack($parse,$data)
  {
    $parselen        = strlen($parse);
    $parsepos        = 0;
    $datapos        = 0;
    $argc                = 1;
    $ret                = array();
                                                                                                                                                                              
    while($parsepos<$parselen){
            $dostr                = false;
            $type        = substr($parse,$parsepos++,1);
            switch($type){
              case 'b':
                      $size        = 1;
                      $argv        .= 'C';
                      break;
              case 's':
                      $size        = 2;
                      $argv        .= 'n';
                      break;
              case 'i':
                      $size        = 4;
                      $argv        .= 'N';
                      break;
              case 'Z':
                      $dostr        = true;
                      /*处理字符传之前的数据*/
                      $arr        = unpack($argv,substr($data,$datapos,$argvlen));
                      $datapos        += $argvlen;
                      $argvlen        = 0;
                      $argv                = '';
                      $ret        = array_merge($ret,$arr);
                      /*获取要解析的字符串的个数，并移动指针*/
                      if($parsepos<$parselen)        $argc        = intval(substr($parse,$parsepos));
                      if($argc==0)        $argc        = 1;
                      while($parsepos<$parselen){
                              $type        = substr($parse,$parsepos,1);
                              if($type>='0'&&$type<='9'){
                                      $parsepos++;
                              }else{
                                      break;
                              }
                      }
                      /*获取字符串的命名*/
                      $namepos= $parsepos;
                      $type   = '';
                      while($parsepos<$parselen){
                              $type= substr($parse,$parsepos,1);
                              $parsepos++;
                              $namelen++;
                              if($type=='/')        break;
                      }
                      $strname = substr($parse,$namepos,$parsepos-$namepos-($type=='/'?1:0));
                                                                                                                                                                                                
                      /*处理各个字符串*/
                      for($i=0;$i<$argc;$i++){
                          $str= '';
                          $crt_len_arr = unpack('nstr_len',substr($data,$datapos,2));
                          $datapos+= 2;
                          $crt_str_len = $crt_len_arr['str_len'];
                          $crt_str = unpack("C{$crt_str_len}str",substr($data,$datapos,$crt_str_len));
                          for($ii=1;$ii<=$crt_str_len;$ii++){
                                  $str.= chr($crt_str['str'.$ii]);
                          }
                                                                                                                                                                                            
                          $ret= array_merge($ret,array($strname.($argc>1?($i+1):'')=>$str));
                          $datapos+= $crt_str_len;
                      }
                      break;
              default:
                      die('parse error');
            }
            if($dostr)        continue;
            /*获取数据长度*/
            if($parsepos<$parselen)    
               $argc  = intval(substr($parse,$parsepos));
            if($argc==0){
                    $argc = 1;
            }else{
                    /*unpack代码限制了只能200*/
                    if($argc>200)    
                      $argc= 200;
            }
            $argvlen+= $argc*$size;
            /*移动解析参数指针*/
            while($parsepos<$parselen){
                    $type = substr($parse,$parsepos,1);
                    $argv .= $type;
                    $parsepos++;
                    if($type=='/') break;
            }
    }
    if(!empty($argv)){
            $ret = array_merge($ret,unpack($argv,substr($data,$datapos)));
    }
    return $ret;
  }
  function pack_str($str){
  //        $str        = iconv('gbk','utf-8',$str);
          $utflen = strlen($str);
          if ($utflen > 65535)    
             die('too long');
          $in  .= pack('C2',$utflen>>8,$utflen>>0);
          return $in.$str;
  }
  $in  .= pack('C',10);
  $in  .= pack_str("标题");
  $in  .= pack('C',10);
  $in  .= pack_str("内容");
  print_r(rs_unpack('bbyte/Zstr/be/Zstrw',$in));
  /*比如java发送int,string,string,分别表示协议号，标题，内容
  这里用php模拟发送的数据
  */
  $in        = pack('N',1000);
  $in        .= pack_str("公告");
  $in        .= pack_str("服务器在10分钟内重启！");
  print_r(rs_unpack('i/Ztitle/Zcontent',$in));
  print_r(rs_unpack('i/Z2str',$in));
?>

需要注意的是:

(1)很多服务器都会用utf8编码的格式，所以我们的php文件也必须使用同样的编码，否则会出乱码,或其他问题

(2)该函数我只处理了4种类行,并且参数用java的类型代替了unpack原来的参数类型,如需处理其他类型，请自行修改。

2.其它举例:

例子1

<?php
$data = "PHP";
print_r(unpack("C*",$data));
?>

输出：

Array
(
[1] => 80
[2] => 72
[3] => 80
)

例子 2

<?php
$data = "PHP";
print_r(unpack("C*myint",$data));
?>

输出：

Array
(
[myint1] => 80
[myint2] => 72
[myint3] => 80
)

例子 3

<?php
$bin = pack("c2n2",0x1234,0x5678,65,66);
print_r(unpack("c2chars/n2int",$bin));
?>

输出：

Array
(
[chars1] => 52
[chars2] => 120
[int1] => 65
[int2] => 66
)

http://www.newsmth.net/nForum/#!article/PHP/88188

转:

PHP与C++通信，发送整型数据。

function MyFunc($userid, $guid)
{
//固定包头
//包ID = (1053)D = (041D)H
//加密码 = 0
//包Len = 8
$packetHead = "\x1D\x04\x00\x08\x00\x00\x00";
Print($userid);
Print($guid);

//构造包体
//UserID
$param1 = getNetByteStream($userid);
//Guid
$param2 = getNetByteStream($guid);
$packetBody = $param1.$param2;

$address = "192.168.0.108";
$service_port = 9005;
$content = $packetHead.$packetBody;

if(($socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP))< 0)
   echo "socket_create() failed: reason: " . socket_strerror($socket) . "\n";
   //echo "Attempting to connect to '$address' on port '$service_port'...";
   if (($result = socket_connect($socket, $address, $service_port))< 0)
   echo "socket_connect() failed.\nReason: ($result) " . socket_strerror($result) . "\n";
   $res = socket_write($socket, $content, 15);
   socket_close($socket);
}

//得到用于传输的网络字节流
function getNetByteStream($n) {

$array = array(0,0,0,0,0,0,0,0);
$i = 0;

//先转成16进制
$temp = $n;
while ($temp != 0) {
  $i++;
  $array[8-$i] = $temp%16 ;
  $temp = floor($temp/16);
}

//字节倒序
for ($i = 0; $i < 4; $i+=2) {
   $t1 = $array[$i];
   $t2 = $array[$i+1];
     $array[$i] = $array[6-$i];
     $array[$i+1] = $array[7-$i];
     $array[6-$i] = $t1;
     $array[7-$i] = $t2;
}

//再转换回来，生成字节流
$strRet = "";
for ($i = 0; $i < 8; $i += 2) {
     $xxx = $array[$i]*16 + $array[$i+1];
     $strRet = $strRet.chr($xxx);
}

return $strRet;

}

假设要生成的struct 结构是这样子的，
struct TEST{
char name[10];
char pass[33];
int age;
unsigned char flag;
};
在php中我用类模拟这个结构体
[php]
class struct{
var $name;
var $pass;
var $age;
var $flag;
function __construct($name,$pass,$age,$flag){
$this->name=$name;
$this->pass=$pass;
$this->age=$age;
$this->flag=$flag;
pack("a10",$this->name);
pack("a33",$this->pass);
pack("i*",$this->age);
pack("C*",$this->flag);
settype($this->name,'string');
settype($this->pass,'string');
settype($this->flag,'int');
settype($this->flag,'string');
}
}
$st=new struct();
$st->name="Test";
$st->pass="Test";
$st->age="5";
$st->flag="1";
print_r($st);
[/php]

$msg = pack("a10",$this->name);
$msg .= pack("a33",$this->pass);
$msg .= pack("i*",$this->age);
$msg .= pack("C*",$this->flag);
就是把数据转成二进制,序列,$msg作为包通过socket,发给c++
当然如果c++ 回给你的包里面有是结构的,二进制序列,你就得用unpack安之前的顺序来解包
不管是c++还是php 发包,都要转成二进制序列, 这个序列的顺序,当然是双方沟通后的结构,也可以是单方定后,告诉另一方.
和写文件一样, 不能一下把一个结构体写到文件里吧.一项一项的顺序还是自己定的

http://bbs.phpchina.com/thread-154118-1-1.html

http://blog.chinaunix.net/uid-20240947-id-108693.html

http://stackoverflow.com/questions/3993762/php-passing-c-struct-data-throught-socket-programming

http://stackoverflow.com/questions/2256879/reading-a-struct-within-a-struct-via-phps-unpack-function/2257189#2257189

会员力量，点亮园子希望

刷新页面返回顶部

有心故我在

php pack、unpack、ord 函数使用方法

php通过pack和unpack函数实现对二进制数据封装及解析

PHP与C++通信，发送整型数据。

About