nelns/admin/public_html/request_interface.php

   1 <?php
   2 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   3 // Copyright (C) 2010  Winch Gate Property Limited
   4 //
   5 // This program is free software: you can redistribute it and/or modify
   6 // it under the terms of the GNU Affero General Public License as
   7 // published by the Free Software Foundation, either version 3 of the
   8 // License, or (at your option) any later version.
   9 //
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU Affero General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU Affero General Public License
  16 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18         class CMemStream
  19         {
  20                 var $Buffer;
  21                 var $InputStream;
  22                 var $Pos;
  23
  24                 function CMemStream ()
  25                 {
  26                         $this->InputStream = false;
  27                         $this->Pos = 0;
  28                 }
  29
  30                 function setBuffer ($buffer)
  31                 {
  32                         $this->InputStream = true;
  33                         $this->Buffer = $buffer;
  34                         $this->Pos = 0;
  35                 }
  36
  37                 function isReading () { return $this->InputStream; }
  38
  39 /*
  40                 function serialuint8 (&$val)
  41                 {
  42                         if ($this->isReading())
  43                         {
  44                                 $val = ord($this->Buffer{$this->Pos++});
  45                                 //printf ("read uint8 '%d'<br>", $val);
  46                         }
  47                         else
  48                         {
  49                                 $this->Buffer .= chr($val & 0xFF);
  50                                 $this->Pos++;
  51                                 //printf ("write uint8 '%d' %d<br>", $val, $this->Pos);
  52                         }
  53                 }
  54
  55                 function serialuint32 (&$val)
  56                 {
  57                         if ($this->isReading())
  58                         {
  59                                 $val = ord($this->Buffer{$this->Pos++});
  60                                 $val += ord($this->Buffer{$this->Pos++})<<8;
  61                                 $val += ord($this->Buffer{$this->Pos++})<<16;
  62                                 $val += ord($this->Buffer{$this->Pos++})<<32;
  63                                 //printf ("read uint32 '%d'<br>", $val);
  64                         }
  65                         else
  66                         {
  67                                 $this->Buffer .= chr($val & 0xFF);
  68                                 $this->Buffer .= chr(($val>>8) & 0xFF);
  69                                 $this->Buffer .= chr(($val>>16) & 0xFF);
  70                                 $this->Buffer .= chr(($val>>24) & 0xFF);
  71                                 $this->Pos += 4;
  72                                 //printf ("write uint32 '%d' %d<br>", $val, $this->Pos);
  73                         }
  74                 }
  75
  76                 function serialstring (&$val)
  77                 {
  78                         if ($this->isReading())
  79                         {
  80                                 $this->serialuint32($size);
  81                                 $val = substr ($this->Buffer, $this->Pos, $size);
  82                                 //printf ("read string '%s'<br>", $val);
  83                                 $this->Pos += strlen($val);
  84                         }
  85                         else
  86                         {
  87                                 $this->serialuint32(strlen($val));
  88                                 $this->Buffer .= $val;
  89                                 $this->Pos += strlen($val);
  90                                 //printf ("write string '%s' %d<br>", $val, $this->Pos);
  91                         }
  92                 }
  93 */
  94
  95                 function serialuint8 (&$val)
  96                 {
  97                         if ($this->isReading())
  98                         {
  99                                 if ($this->Pos+1 > strlen($this->Buffer))
 100                                         return false;
 101
 102                                 $val = ord($this->Buffer{$this->Pos++});
 103                                 //printf ("read uint8 '%d'<br>", $val);
 104                         }
 105                         else
 106                         {
 107                                 $this->Buffer .= chr($val & 0xFF);
 108                                 $this->Pos++;
 109                                 //printf ("write uint8 '%d' %d<br>", $val, $this->Pos);
 110                         }
 111                         return true;
 112                 }
 113
 114                 function serialuint32 (&$val)
 115                 {
 116                         if ($this->isReading())
 117                         {
 118                                 if ($this->Pos+4 > strlen($this->Buffer))
 119                                         return false;
 120
 121                                 $val = ord($this->Buffer{$this->Pos++});
 122                                 $val += ord($this->Buffer{$this->Pos++})<<8;
 123                                 $val += ord($this->Buffer{$this->Pos++})<<16;
 124                                 $val += ord($this->Buffer{$this->Pos++})<<32;
 125                                 //printf ("read uint32 '%d'<br>", $val);
 126                         }
 127                         else
 128                         {
 129                                 $this->Buffer .= chr($val & 0xFF);
 130                                 $this->Buffer .= chr(($val>>8) & 0xFF);
 131                                 $this->Buffer .= chr(($val>>16) & 0xFF);
 132                                 $this->Buffer .= chr(($val>>24) & 0xFF);
 133                                 $this->Pos += 4;
 134                                 //printf ("write uint32 '%d' %d<br>", $val, $this->Pos);
 135                         }
 136                         return true;
 137                 }
 138
 139                 function serialstring (&$val)
 140                 {
 141                         if ($this->isReading())
 142                         {
 143                                 if (!$this->serialuint32($size))
 144                                         return false;
 145
 146                                 if ($this->Pos+$size > strlen($this->Buffer))
 147                                         return false;
 148
 149                                 $val = substr ($this->Buffer, $this->Pos, $size);
 150                                 //printf ("read string '%s'<br>", $val);
 151                                 $this->Pos += strlen($val);
 152                         }
 153                         else
 154                         {
 155                                 $this->serialuint32(strlen($val));
 156                                 $this->Buffer .= $val;
 157                                 $this->Pos += strlen($val);
 158                                 //printf ("write string '%s' %d<br>", $val, $this->Pos);
 159                         }
 160                         return true;
 161                 }
 162
 163         }
 164
 165         // This function connect to the AS.
 166         // If true, $res contains the url to connect.
 167         // If false, $res contains the reason why it s not okay.
 168
 169         function connectToAS(&$fp, &$res, $asHost, $asPort)
 170         {
 171                 // connect to the login service that must be $ASHost:$ASPort
 172                 $fp = fsockopen ($asHost, $asPort, $errno, $errstr, 30);
 173                 if (!$fp)
 174                 {
 175                         $res = "Can't connect to the admin service '$ASHost:$ASPort' ($errno: $errstr)";
 176                 }
 177                 else
 178                 {
 179                         $res = "";
 180                 }
 181         }
 182
 183         function disconnectFromAS(&$fp)
 184         {
 185                 fclose($fp);
 186         }
 187
 188         function sendMessage ($fp, $msgout)
 189         {
 190                 $size = $msgout->Pos;
 191                 $buffer = chr(($size>>24)&0xFF);
 192                 $buffer .= chr(($size>>16)&0xFF);
 193                 $buffer .= chr(($size>>8)&0xFF);
 194                 $buffer .= chr($size&0xFF);
 195                 $buffer .= $msgout->Buffer;
 196
 197                 fwrite ($fp, $buffer);
 198
 199                 fflush ($fp);
 200
 201                 return true;
 202         }
 203
 204         function logToFile($msg)
 205         {
 206                 $f = fopen("../log_admin_tool.txt", "a");
 207                 if ($f)
 208                 {
 209                         fwrite($f, "$msg\n");
 210                         fflush($f);
 211                         fclose($f);
 212                 }
 213         }
 214 /*
 215         function waitMessage ($fp, &$msgin)
 216         {
 217                 $size = 0;
 218                 $val = fread ($fp, 1);
 219                 $size = ord($val) << 24;
 220                 $val = fread ($fp, 1);
 221                 $size = ord($val) << 16;
 222                 $val = fread ($fp, 1);
 223                 $size += ord($val) << 8;
 224                 $val = fread ($fp, 1);
 225                 $size += ord($val);
 226                 $fake = fread ($fp, 4);
 227                 $size -= 4; // remove the fake
 228
 229                 $buffer = '';
 230                 do
 231                 {
 232                         $buffer .= fread ($fp, $size);
 233                         //logToFile("read ".strlen($buffer)." bytes...");
 234                         if (feof($fp))
 235                                 break;
 236                 }
 237                 while (strlen($buffer) != $size);
 238
 239                 //logToFile("finished read ".strlen($buffer)." bytes!!");
 240
 241                 $msgin = new CMemStream;
 242                 $msgin->setBuffer ($buffer);
 243
 244                 //logToFile("leave wait message");
 245                 return true;
 246         }
 247 */
 248         function waitMessage ($fp, &$msgin)
 249         {
 250                 //echo "waiting a message";
 251                 $size = 0;
 252                 $val = fread ($fp, 1);
 253                 if (feof ($fp)) return false;
 254                 $size = ord($val) << 24;
 255                 $val = fread ($fp, 1);
 256                 if (feof ($fp)) return false;
 257                 $size = ord($val) << 16;
 258                 $val = fread ($fp, 1);
 259                 if (feof ($fp)) return false;
 260                 $size += ord($val) << 8;
 261                 $val = fread ($fp, 1);
 262                 if (feof ($fp)) return false;
 263                 $size += ord($val);
 264                 //printf ("receive packet size '%d'<br>", $size);
 265                 $fake = fread ($fp, 4);
 266                 if (feof ($fp)) return false;
 267                 $size -= 4; // remove the fake
 268
 269                 $buffer = '';
 270                 while (($stillNotRead = $size-strlen($buffer)) > 0)
 271                 {
 272                         $buffer .= fread ($fp, $stillNotRead);
 273                         if (feof ($fp)) return false;
 274                 }
 275
 276                 $msgin = new CMemStream;
 277                 $msgin->setBuffer ($buffer);
 278
 279                 return true;
 280         }
 281
 282         function logNelQuery($query)
 283         {
 284                 global  $uid;
 285 /*
 286                 $f = fopen("./nel_queries.log", "a");
 287                 fwrite($f, date("Y/m/d H:i:s")." ".sprintf("%-16s", $admlogin)." $query\n");
 288                 fclose($f);
 289 */
 290                 logUser($uid, "QUERY=".$query);
 291         }
 292
 293
 294         function        queryToAS($rawvarpath, &$result, $asAddr, $asPort)
 295         {
 296                 global                  $nel_queries;
 297
 298                 $nel_queries[] = $rawvarpath;
 299                 $ok = false;
 300
 301                 connectToAS($fp, $result, $asAddr, $asPort);
 302                 if(strlen($result) != 0)
 303                         return $ok;
 304
 305                 // send the message that say that we want to add a user
 306                 $msgout = new CMemStream;
 307                 $fake = 0;
 308                 $msgout->serialuint32 ($fake);                  // fake used to number the packet
 309                 $messageType = 0;
 310                 $msgout->serialuint8 ($messageType);
 311                 $msgout->serialstring ($rawvarpath);
 312
 313                 sendMessage ($fp, $msgout);
 314
 315                 waitMessage ($fp, $msgin);
 316
 317                 $msgin->serialstring($result);
 318
 319                 if(strlen($result) == 0)
 320                 {
 321                         // it failed
 322                 }
 323                 else
 324                 {
 325                         // it's ok
 326                         $ok = true;
 327                 }
 328
 329                 disconnectFromAS(&$fp);
 330
 331                 return $ok;
 332         }
 333
 334
 335         function nel_query($rawvarpath, &$result)
 336         {
 337                 global  $ASHost, $ASPort;
 338
 339                 $shards = getShardListFromQuery($rawvarpath);
 340                 $as = getASList($shards);
 341
 342                 if (count($as) <= 1)
 343                 {
 344                         $asHost = $ASHost;
 345                         $asPort = $ASPort;
 346
 347                         if (count($as) > 0)
 348                         {
 349                                 foreach ($as as $asHost)
 350                                 {
 351                                         $pos = strpos($asHost, ':');
 352                                         if (pos != FALSE)
 353                                         {
 354                                                 $asPort = substr($asHost, $pos+1);
 355                                                 $asHost = substr($asHost, 0, $pos);
 356                                         }
 357                                 }
 358                         }
 359
 360                         $res = queryToAS($rawvarpath, $result, $asHost, $asPort);
 361                 }
 362                 else
 363                 {
 364                         $resCols = array();
 365                         $resArray = array();
 366
 367                         $res = false;
 368
 369                         foreach ($as as $asHost)
 370                         {
 371                                 $asPort = $ASPort;
 372                                 $pos = strpos($asHost, ':');
 373                                 if (pos != FALSE)
 374                                 {
 375                                         $asPort = substr($asHost, $pos+1);
 376                                         $asHost = substr($asHost, 0, $pos);
 377                                 }
 378
 379                                 $tmp = queryToAS($rawvarpath, $qres, $asHost, $asPort);
 380                                 if ($tmp)
 381                                 {
 382                                         $res = true;
 383                                         mergeResult($qres, $resCols, $resArray);
 384                                 }
 385                         }
 386
 387                         //print_r($resCols);echo '<br>';
 388                         //print_r($resArray);echo '<br>';
 389                         $result = rebuildResult($resCols, $resArray);
 390                 }
 391
 392                 return res;
 393         }
 394
 395
 396         function        getShardFromSimpleQuery($query, $startpos=0)
 397         {
 398                 $pos = $startpos;
 399                 while ($pos < strlen($query) && $query[$pos] != '.' && $query[$pos] != ']' && $query[$pos] != ',')
 400                         ++$pos;
 401                 //echo 'getShardFromSimpleQuery: '.substr($query, $startpos, $pos-$startpos).'<br>';
 402                 return substr($query, $startpos, $pos-$startpos);
 403         }
 404
 405         function        getShardListFromQuery($query, $startpos=0)
 406         {
 407                 $shards = array();
 408
 409                 if ($query[$startpos] != '[')
 410                 {
 411                         $shards[] = getShardFromSimpleQuery($query, $startpos);
 412                         return $shards;
 413                 }
 414
 415                 $pos = $startpos+1;
 416                 $lvl = 0;
 417
 418                 while (true)
 419                 {
 420                         //echo 'getShardListFromQuery in '.substr($query, $pos).'<br>';
 421                         $shards = array_merge($shards, getShardListFromQuery($query, $pos));
 422
 423                         while ($pos<strlen($query) && ($query[$pos]!=',' || $lvl>0))
 424                         {
 425                                 if ($query[$pos] == '[')        ++$lvl;
 426                                 if ($query[$pos] == ']')        --$lvl;
 427                                 ++$pos;
 428                         }
 429
 430                         if ($query[$pos] != ',')
 431                                 break;
 432
 433                         ++$pos;
 434                 }
 435
 436                 return array_unique($shards);
 437         }
 438
 439         function        selectAllAS()
 440         {
 441                 global  $ASHost, $ASPort;
 442
 443                 $as[] = $ASHost.':'.$ASPort;
 444
 445                 foreach($shardLockState as $shard)
 446                         if ($shard['ASAddr'] != '')
 447                                 $as[] = $shard[ASAddr];
 448
 449                 return array_unique($as);
 450         }
 451
 452         function        getASList($shards)
 453         {
 454                 global  $ASHost, $ASPort, $shardLockState;
 455
 456                 if (count($shards) == 0)
 457                         return;
 458
 459                 if (array_search('*', $shards) != FALSE)
 460                         return selectAllAS();
 461
 462                 foreach($shards as $shard)
 463                         if ($shardLockState[$shard]['ASAddr'] != '')
 464                                 $as[$shard] = $shardLockState[$shard]['ASAddr'];
 465                         else
 466                                 $as[$shard] = $ASHost.':'.$ASPort;
 467
 468                 return array_unique($as);
 469         }
 470
 471         function        mergeResult(&$res, &$resCols, &$resArray)
 472         {
 473                 $resV = explode(' ', $res);
 474
 475                 $i = 0;
 476                 $numCols = $resV[$i++];
 477                 for ($i=1; $i<=$numCols; ++$i)
 478                         if (!isset($resCols[$resV[$i]]))
 479                                 $resCols[$resV[$i]] = count($resCols);
 480
 481                 while ($i < count($resV))
 482                 {
 483                         //echo 'examine i='.$i.', resv='.count($resV).'<br>';
 484
 485                         $line = array();
 486                         for ($j=0; $j<$numCols; ++$j)
 487                         {
 488                                 $line[ $resCols[$resV[$j+1]] ] = $resV[$i++];
 489
 490                                 if ($i > count($resV))
 491                                         break;
 492                         }
 493                         if ($j>=$numCols)
 494                                 $resArray[] = $line;
 495                 }
 496         }
 497
 498         function        rebuildResult(&$resCols, &$resArray)
 499         {
 500                 $numCols = count($resCols);
 501
 502                 $res = $numCols;
 503
 504                 foreach($resCols as $col => $id)
 505                         $res .= ' '.$col;
 506
 507                 //$res .= join(' ', $resCols);
 508
 509                 $numRows = count($resArray);
 510                 if ($numRows == 0)
 511                         return $res;
 512
 513                 for ($i=0; $i<$numRows; ++$i)
 514                 {
 515                         $line = &$resArray[$i];
 516                         //print_r($line); echo '<br>';
 517                         if (count($line) == 0)
 518                                 continue;
 519
 520                         foreach ($resCols as $col => $id)
 521                         {
 522                                 $v = &$line[$id];
 523                                 if (!isset($v) || $v == '')
 524                                         $res .= ' ???';
 525                                 else
 526                                         $res .= ' '.$v;
 527                         }
 528                 }
 529
 530                 return $res;
 531         }
 532 ?>