BVB Source Codes

The latest thinkphp v5.2 work order system Show HproseHttpServer.php Source code

Return Download The latest thinkphp v5.2 work order system: download HproseHttpServer.php Source code - Download The latest thinkphp v5.2 work order system Source code - Type:.php
  1. <?php
  2. /**********************************************************\
  3. |                                                          |
  4. |                          hprose                          |
  5. |                                                          |
  6. | Official WebSite: http://www.hprose.com/                 |
  7. |                   http://www.hprose.net/                 |
  8. |                   http://www.hprose.org/                 |
  9. |                                                          |
  10. \**********************************************************/
  11.  
  12. /**********************************************************\
  13.  *                                                        *
  14.  * HproseHttpServer.php                                   *
  15.  *                                                        *
  16.  * hprose http server library for php5.                   *
  17.  *                                                        *
  18.  * LastModified: Nov 13, 2013                             *
  19.  * Author: Ma Bingyao <andot@hprfc.com>                   *
  20.  *                                                        *
  21. \**********************************************************/
  22.  
  23. require_once('HproseCommon.php');
  24. require_once('HproseIO.php');
  25.  
  26. class HproseHttpServer {
  27.     private $errorTable = array(E_ERROR => 'Error',
  28.                                 E_WARNING => 'Warning',
  29.                                 E_PARSE => 'Parse Error',
  30.                                 E_NOTICE => 'Notice',
  31.                                 E_CORE_ERROR => 'Core Error',
  32.                                 E_CORE_WARNING => 'Core Warning',
  33.                                 E_COMPILE_ERROR => 'Compile Error',
  34.                                 E_COMPILE_WARNING => 'Compile Warning',
  35.                                 E_USER_ERROR => 'User Error',
  36.                                 E_USER_WARNING => 'User Warning',
  37.                                 E_USER_NOTICE => 'User Notice',
  38.                                 E_STRICT => 'Run-time Notice',
  39.                                 E_RECOVERABLE_ERROR => 'Error');
  40.     private $functions;
  41.     private $funcNames;
  42.     private $resultModes;
  43.     private $simpleModes;
  44.     private $debug;
  45.     private $crossDomain;
  46.     private $P3P;
  47.     private $get;
  48.     private $input;
  49.     private $output;
  50.     private $error;
  51.     private $filter;
  52.     private $simple;
  53.     public $onBeforeInvoke;
  54.     public $onAfterInvoke;
  55.     public $onSendHeader;
  56.     public $onSendError;
  57.     public function __construct() {
  58.         $this->functions = array();
  59.         $this->funcNames = array();
  60.         $this->resultModes = array();
  61.         $this->simpleModes = array();
  62.         $this->debug = false;
  63.         $this->crossDomain = false;
  64.         $this->P3P = false;
  65.         $this->get = true;
  66.         $this->filter = NULL;
  67.         $this->simple = false;
  68.         $this->error_types = E_ALL & ~E_NOTICE;
  69.         $this->onBeforeInvoke = NULL;
  70.         $this->onAfterInvoke = NULL;
  71.         $this->onSendHeader = NULL;
  72.         $this->onSendError = NULL;
  73.     }
  74.     /*
  75.       __filterHandler & __errorHandler must be public,
  76.       however we should never call them directly.
  77.     */
  78.     public function __filterHandler($data) {
  79.         if (preg_match('/<b>.*? error<\/b>:(.*?)<br/', $data, $match)) {
  80.             if ($this->debug) {
  81.                 $error = preg_replace('/<.*?>/', '', $match[1]);
  82.             }
  83.             else {
  84.                 $error = preg_replace('/ in <b>.*<\/b>$/', '', $match[1]);
  85.             }
  86.             $data = HproseTags::TagError .
  87.                  HproseFormatter::serialize(trim($error), true) .
  88.                  HproseTags::TagEnd;
  89.         }
  90.         if ($this->filter) $data = $this->filter->outputFilter($data);
  91.         return $data;
  92.     }
  93.     public function __errorHandler($errno, $errstr, $errfile, $errline) {
  94.         if ($this->debug) {
  95.             $errstr .= " in $errfile on line $errline";
  96.         }
  97.         $this->error = $this->errorTable[$errno] . ": " . $errstr;
  98.         $this->sendError();
  99.         return true;
  100.     }
  101.     private function sendHeader() {
  102.         if ($this->onSendHeader) {
  103.             call_user_func($this->onSendHeader);
  104.         }
  105.         header("Content-Type: text/plain");
  106.         if ($this->P3P) {
  107.             header('P3P: CP="CAO DSP COR CUR ADM DEV TAI PSA PSD IVAi IVDi ' .
  108.                    'CONi TELo OTPi OUR DELi SAMi OTRi UNRi PUBi IND PHY ONL ' .
  109.                    'UNI PUR FIN COM NAV INT DEM CNT STA POL HEA PRE GOV"');
  110.         }
  111.         if ($this->crossDomain) {
  112.             if (array_key_exists('HTTP_ORIGIN', $_SERVER) && $_SERVER['HTTP_ORIGIN'] != "null") {
  113.                 header("Access-Control-Allow-Origin: " . $_SERVER['HTTP_ORIGIN']);
  114.                 header("Access-Control-Allow-Credentials: true");  
  115.             }
  116.             else {
  117.                 header('Access-Control-Allow-Origin: *');
  118.             }
  119.         }
  120.     }
  121.     private function sendError() {
  122.         if ($this->onSendError) {
  123.             call_user_func($this->onSendError, $this->error);
  124.         }
  125.         ob_clean();
  126.         $this->output->write(HproseTags::TagError);
  127.         $writer = new HproseSimpleWriter($this->output);
  128.         $writer->writeString($this->error);
  129.         $this->output->write(HproseTags::TagEnd);
  130.         ob_end_flush();
  131.     }
  132.     private function doInvoke() {
  133.         $simpleReader = new HproseSimpleReader($this->input);
  134.         do {
  135.             $functionName = $simpleReader->readString(true);
  136.             $aliasName = strtolower($functionName);
  137.             $resultMode = HproseResultMode::Normal;
  138.             if (array_key_exists($aliasName, $this->functions)) {
  139.                 $function = $this->functions[$aliasName];
  140.                 $resultMode = $this->resultModes[$aliasName];
  141.                 $simple = $this->simpleModes[$aliasName];
  142.             }
  143.             elseif (array_key_exists('*', $this->functions)) {
  144.                 $function = $this->functions['*'];
  145.                 $resultMode = $this->resultModes['*'];
  146.                 $simple = $this->resultModes['*'];
  147.             }
  148.             else {
  149.                 throw new HproseException("Can't find this function " . $functionName . "().");
  150.             }
  151.             if ($simple === NULL) $simple = $this->simple;
  152.             $writer = ($simple ? new HproseSimpleWriter($this->output) : new HproseWriter($this->output));
  153.             $args = array();
  154.             $byref = false;
  155.             $tag = $simpleReader->checkTags(array(HproseTags::TagList,
  156.                                             HproseTags::TagEnd,
  157.                                             HproseTags::TagCall));
  158.             if ($tag == HproseTags::TagList) {
  159.                 $reader = new HproseReader($this->input);
  160.                 $args = &$reader->readList();
  161.                 $tag = $reader->checkTags(array(HproseTags::TagTrue,
  162.                                                 HproseTags::TagEnd,
  163.                                                 HproseTags::TagCall));
  164.                 if ($tag == HproseTags::TagTrue) {
  165.                     $byref = true;
  166.                     $tag = $reader->checkTags(array(HproseTags::TagEnd,
  167.                                                     HproseTags::TagCall));
  168.                 }
  169.             }
  170.             if ($this->onBeforeInvoke) {
  171.                 call_user_func($this->onBeforeInvoke, $functionName, $args, $byref);
  172.             }
  173.             if (array_key_exists('*', $this->functions) && ($function === $this->functions['*'])) {
  174.                 $arguments = array($functionName, &$args);
  175.             }
  176.             elseif ($byref) {
  177.                 $arguments = array();
  178.                 for ($i = 0; $i < count($args); $i++) {
  179.                     $arguments[$i] = &$args[$i];
  180.                 }
  181.             }
  182.             else {
  183.                 $arguments = $args;
  184.             }
  185.             $result = call_user_func_array($function, $arguments);
  186.             if ($this->onAfterInvoke) {
  187.                 call_user_func($this->onAfterInvoke, $functionName, $args, $byref, $result);
  188.             }
  189.             // some service functions/methods may echo content, we need clean it
  190.             ob_clean();
  191.             if ($resultMode == HproseResultMode::RawWithEndTag) {
  192.                 $this->output->write($result);
  193.                 return;
  194.             }
  195.             elseif ($resultMode == HproseResultMode::Raw) {
  196.                 $this->output->write($result);
  197.             }
  198.             else {
  199.                 $this->output->write(HproseTags::TagResult);
  200.                 if ($resultMode == HproseResultMode::Serialized) {
  201.                     $this->output->write($result);
  202.                 }
  203.                 else {
  204.                     $writer->reset();
  205.                     $writer->serialize($result);
  206.                 }
  207.                 if ($byref) {
  208.                     $this->output->write(HproseTags::TagArgument);
  209.                     $writer->reset();
  210.                     $writer->writeList($args);
  211.                 }
  212.             }
  213.         } while ($tag == HproseTags::TagCall);
  214.         $this->output->write(HproseTags::TagEnd);
  215.         ob_end_flush();
  216.     }
  217.     private function doFunctionList() {
  218.         $functions = array_values($this->funcNames);
  219.         $writer = new HproseSimpleWriter($this->output);
  220.         $this->output->write(HproseTags::TagFunctions);
  221.         $writer->writeList($functions);
  222.         $this->output->write(HproseTags::TagEnd);
  223.         ob_end_flush();
  224.     }
  225.     private function getDeclaredOnlyMethods($class) {
  226.         $all = get_class_methods($class);
  227.         if ($parent_class = get_parent_class($class)) {
  228.             $inherit = get_class_methods($parent_class);
  229.             $result = array_diff($all, $inherit);
  230.         }
  231.         else {
  232.             $result = $all;
  233.         }
  234.         return $result;
  235.     }
  236.     public function addMissingFunction($function, $resultMode = HproseResultMode::Normal, $simple = NULL) {
  237.         $this->addFunction($function, '*', $resultMode, $simple);
  238.     }
  239.     public function addFunction($function, $alias = NULL, $resultMode = HproseResultMode::Normal, $simple = NULL) {
  240.         if (is_callable($function)) {
  241.             if ($alias === NULL) {
  242.                 if (is_string($function)) {
  243.                     $alias = $function;
  244.                 }
  245.                 else {
  246.                     $alias = $function[1];
  247.                 }
  248.             }
  249.             if (is_string($alias)) {
  250.                 $aliasName = strtolower($alias);
  251.                 $this->functions[$aliasName] = $function;
  252.                 $this->funcNames[$aliasName] = $alias;
  253.                 $this->resultModes[$aliasName] = $resultMode;
  254.                 $this->simpleModes[$aliasName] = $simple;
  255.             }
  256.             else {
  257.                 throw new HproseException('Argument alias is not a string');
  258.             }
  259.         }
  260.         else {
  261.             throw new HproseException('Argument function is not a callable variable');
  262.         }
  263.     }
  264.     public function addFunctions($functions, $aliases = NULL, $resultMode = HproseResultMode::Normal, $simple = NULL) {
  265.         $aliases_is_null = ($aliases === NULL);
  266.         $count = count($functions);
  267.         if (!$aliases_is_null && $count != count($aliases)) {
  268.             throw new HproseException('The count of functions is not matched with aliases');
  269.         }
  270.         for ($i = 0; $i < $count; $i++) {
  271.             $function = $functions[$i];
  272.             if ($aliases_is_null) {
  273.                 $this->addFunction($function, NULL, $resultMode, $simple);
  274.             }
  275.             else {
  276.                 $this->addFunction($function, $aliases[$i], $resultMode, $simple);
  277.             }
  278.         }
  279.     }
  280.     public function addMethod($methodname, $belongto, $alias = NULL, $resultMode = HproseResultMode::Normal, $simple = NULL) {
  281.         if ($alias === NULL) {
  282.             $alias = $methodname;
  283.         }
  284.         if (is_string($belongto)) {
  285.             $this->addFunction(array($belongto, $methodname), $alias, $resultMode, $simple);
  286.         }
  287.         else {
  288.             $this->addFunction(array(&$belongto, $methodname), $alias, $resultMode, $simple);
  289.         }
  290.     }
  291.     public function addMethods($methods, $belongto, $aliases = NULL, $resultMode = HproseResultMode::Normal, $simple = NULL) {
  292.         $aliases_is_null = ($aliases === NULL);
  293.         $count = count($methods);
  294.         if (is_string($aliases)) {
  295.             $aliasPrefix = $aliases;
  296.             $aliases = array();
  297.             foreach ($methods as $name) {
  298.                 $aliases[] = $aliasPrefix . '_' . $name;
  299.             }
  300.         }
  301.         if (!$aliases_is_null && $count != count($aliases)) {
  302.             throw new HproseException('The count of methods is not matched with aliases');
  303.         }
  304.         for ($i = 0; $i < $count; $i++) {
  305.             $method = $methods[$i];
  306.             if (is_string($belongto)) {
  307.                 $function = array($belongto, $method);
  308.             }
  309.             else {
  310.                 $function = array(&$belongto, $method);
  311.             }
  312.             if ($aliases_is_null) {
  313.                 $this->addFunction($function, $method, $resultMode, $simple);
  314.             }
  315.             else {
  316.                 $this->addFunction($function, $aliases[$i], $resultMode, $simple);
  317.             }
  318.         }
  319.     }
  320.     public function addInstanceMethods($object, $class = NULL, $aliasPrefix = NULL, $resultMode = HproseResultMode::Normal, $simple = NULL) {
  321.         if ($class === NULL) $class = get_class($object);
  322.         $this->addMethods($this->getDeclaredOnlyMethods($class), $object, $aliasPrefix, $resultMode, $simple);
  323.     }
  324.     public function addClassMethods($class, $execclass = NULL, $aliasPrefix = NULL, $resultMode = HproseResultMode::Normal, $simple = NULL) {
  325.         if ($execclass === NULL) $execclass = $class;
  326.         $this->addMethods($this->getDeclaredOnlyMethods($class), $execclass, $aliasPrefix, $resultMode, $simple);
  327.     }
  328.     public function add() {
  329.         $args_num = func_num_args();
  330.         $args = func_get_args();
  331.         switch ($args_num) {
  332.             case 1: {
  333.                 if (is_callable($args[0])) {
  334.                     return $this->addFunction($args[0]);
  335.                 }
  336.                 elseif (is_array($args[0])) {
  337.                     return $this->addFunctions($args[0]);
  338.                 }
  339.                 elseif (is_object($args[0])) {
  340.                     return $this->addInstanceMethods($args[0]);
  341.                 }
  342.                 elseif (is_string($args[0])) {
  343.                     return $this->addClassMethods($args[0]);
  344.                 }
  345.                 break;
  346.             }
  347.             case 2: {
  348.                 if (is_callable($args[0]) && is_string($args[1])) {
  349.                     return $this->addFunction($args[0], $args[1]);
  350.                 }
  351.                 elseif (is_string($args[0])) {
  352.                     if (is_string($args[1]) && !is_callable(array($args[1], $args[0]))) {
  353.                         if (class_exists($args[1])) {
  354.                             return $this->addClassMethods($args[0], $args[1]);
  355.                         }
  356.                         else {
  357.                             return $this->addClassMethods($args[0], NULL, $args[1]);
  358.                         }
  359.                     }
  360.                     return $this->addMethod($args[0], $args[1]);
  361.                 }
  362.                 elseif (is_array($args[0])) {
  363.                     if (is_array($args[1])) {
  364.                         return $this->addFunctions($args[0], $args[1]);
  365.                     }
  366.                     else {
  367.                         return $this->addMethods($args[0], $args[1]);
  368.                     }
  369.                 }
  370.                 elseif (is_object($args[0])) {
  371.                     return $this->addInstanceMethods($args[0], $args[1]);
  372.                 }
  373.                 break;
  374.             }
  375.             case 3: {
  376.                 if (is_callable($args[0]) && is_null($args[1]) && is_string($args[2])) {
  377.                     return $this->addFunction($args[0], $args[2]);
  378.                 }
  379.                 elseif (is_string($args[0]) && is_string($args[2])) {
  380.                     if (is_string($args[1]) && !is_callable(array($args[0], $args[1]))) {
  381.                         return $this->addClassMethods($args[0], $args[1], $args[2]);
  382.                     }
  383.                     else {
  384.                         return $this->addMethod($args[0], $args[1], $args[2]);
  385.                     }
  386.                 }
  387.                 elseif (is_array($args[0])) {
  388.                     if (is_null($args[1]) && is_array($args[2])) {
  389.                         return $this->addFunctions($args[0], $args[2]);
  390.                     }
  391.                     else {
  392.                         return $this->addMethods($args[0], $args[1], $args[2]);
  393.                     }
  394.                 }
  395.                 elseif (is_object($args[0])) {
  396.                     return $this->addInstanceMethods($args[0], $args[1], $args[2]);
  397.                 }
  398.                 break;
  399.             }
  400.             throw new HproseException('Wrong arguments');
  401.         }
  402.     }
  403.     public function isDebugEnabled() {
  404.         return $this->debug;
  405.     }
  406.     public function setDebugEnabled($enable = true) {
  407.         $this->debug = $enable;
  408.     }
  409.     public function isCrossDomainEnabled() {
  410.         return $this->crossDomain;
  411.     }
  412.     public function setCrossDomainEnabled($enable = true) {
  413.         $this->crossDomain = $enable;
  414.     }
  415.     public function isP3PEnabled() {
  416.         return $this->P3P;
  417.     }
  418.     public function setP3PEnabled($enable = true) {
  419.         $this->P3P = $enable;
  420.     }
  421.     public function isGetEnabled() {
  422.         return $this->get;
  423.     }
  424.     public function setGetEnabled($enable = true) {
  425.         $this->get = $enable;
  426.     }
  427.     public function getFilter() {
  428.         return $this->filter;
  429.     }
  430.     public function setFilter($filter) {
  431.         $this->filter = $filter;
  432.     }
  433.     public function getSimpleMode() {
  434.         return $this->simple;
  435.     }
  436.     public function setSimpleMode($simple = true) {
  437.         $this->simple = $simple;
  438.     }
  439.     public function getErrorTypes() {
  440.         return $this->error_types;
  441.     }
  442.     public function setErrorTypes($error_types) {
  443.         $this->error_types = $error_types;
  444.     }
  445.     public function handle() {
  446.         if (!isset($HTTP_RAW_POST_DATA)) $HTTP_RAW_POST_DATA = file_get_contents("php://input");
  447.         if ($this->filter) $HTTP_RAW_POST_DATA = $this->filter->inputFilter($HTTP_RAW_POST_DATA);
  448.         $this->input = new HproseStringStream($HTTP_RAW_POST_DATA);
  449.         $this->output = new HproseFileStream(fopen('php://output', 'wb'));
  450.         set_error_handler(array(&$this, '__errorHandler'), $this->error_types);
  451.         ob_start(array(&$this, "__filterHandler"));
  452.         ob_implicit_flush(0);
  453.         ob_clean();
  454.         $this->sendHeader();
  455.         if (($_SERVER['REQUEST_METHOD'] == 'GET') and $this->get) {
  456.             return $this->doFunctionList();
  457.         }
  458.         elseif ($_SERVER['REQUEST_METHOD'] == 'POST') {
  459.             try {
  460.                 switch ($this->input->getc()) {
  461.                     case HproseTags::TagCall: return $this->doInvoke();
  462.                     case HproseTags::TagEnd: return $this->doFunctionList();
  463.                     default: throw new HproseException("Wrong Request: \r\n" . $HTTP_RAW_POST_DATA);
  464.                 }
  465.             }
  466.             catch (Exception $e) {
  467.                 $this->error = $e->getMessage();
  468.                 if ($this->debug) {
  469.                     $this->error .= "\nfile: " . $e->getFile() .
  470.                                     "\nline: " . $e->getLine() .
  471.                                     "\ntrace: " . $e->getTraceAsString();
  472.                 }
  473.                 $this->sendError();
  474.             }
  475.         }
  476.         $this->input->close();
  477.         $this->output->close();
  478.     }
  479.     public function start() {
  480.         $this->handle();
  481.     }
  482. }
  483. ?>
downloadHproseHttpServer.php Source code - Download The latest thinkphp v5.2 work order system Source code
Related Source Codes/Software:
V3.3.6 Workerman high-performance PHP Socket (framework) - High performance PHP Socket framework Workerman re... 2017-05-03
The phosphor meeting room reservation system MRBS (loop reservation v16.0) - The phosphor meeting room reservation system MRBS ... 2017-05-03
IDC v5.2.3 agent center - IDC Centre IDC for exploitation is a PHP+MySQL age... 2017-05-03
Zen master v9.0.1 project management software - Zen is the first domestic open source project mana... 2017-05-03
Ray speed v7.03 employee files management system - Employee files project is various, and some conten... 2017-05-03
HITCMS Haitian responsive electronic mechanical v3.0 foreign trade website source code - HITCMS Haitian response electronic machinery trade... 2017-05-03
Ray v7.02 speed survey system - Lightning speed survey system is a. NET+MSSQL deve... 2017-05-03
Cool HITCMS reactive black v3.0 enterprise website source code - HITCMS-Haitian response black enterprises website ... 2017-05-03
WebOA v17.2 network office automation system - WebOA network using b/s structure development of o... 2017-05-03
Pure imitation of han site source code, one a 】 【 c9cms kernel v1.0 - Generic http://www.wufazhuce.com/Han one · Config... 2017-05-04
zone.js - Implements Zones for JavaScript ... 2017-05-11
dragonfly - A Ruby gem for on-the-fly processing - suitable fo... 2017-05-11
oh-my-fish - The Fishshell Framework. 2017-05-11
canvas-lms - The open LMS by Instructure, Inc. 2017-05-11
ledger - Double-entry accounting system with a command-line... 2017-05-11
Python - My Python Examples http://w... 2017-05-11
blade - 2017-05-11
LaZagne - Credentials recovery project 2017-05-10
Pull-to-Refresh.Rentals-iOS - This project aims to provide a simple and customiz... 2017-05-10
spoon - Distributing instrumentation tests to all your And... 2017-05-10

 Back to top