<?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']);

$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())

);

<?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);

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)

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

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

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

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

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

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

$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

输出：

例子 2

输出：

例子 3

输出：

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]

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