webservice/lib.php

   1 <?php
   2
   3 // This file is part of Moodle - http://moodle.org/
   4 //
   5 // Moodle is free software: you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation, either version 3 of the License, or
   8 // (at your option) any later version.
   9 //
  10 // Moodle 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 General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU General Public License
  16 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  17
  18 /**
  19  * Web services utility functions and classes
  20  *
  21  * @package   webservice
  22  * @copyright 2009 Moodle Pty Ltd (http://moodle.com)
  23  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  24  */
  25
  26 require_once($CFG->libdir.'/externallib.php');
  27
  28 /**
  29  * Exception indicating access control problem in web service call
  30  * @author Petr Skoda (skodak)
  31  */
  32 class webservice_access_exception extends moodle_exception {
  33     /**
  34      * Constructor
  35      */
  36     function __construct($debuginfo) {
  37         parent::__construct('accessexception', 'webservice', '', null, $debuginfo);
  38     }
  39 }
  40
  41 /**
  42  * Is protocol enabled?
  43  * @param string $protocol name of WS protocol
  44  * @return bool
  45  */
  46 function webservice_protocol_is_enabled($protocol) {
  47     global $CFG;
  48
  49     if (empty($CFG->enablewebservices)) {
  50         return false;
  51     }
  52
  53     $active = explode(',', $CFG->webserviceprotocols);
  54
  55     return(in_array($protocol, $active));
  56 }
  57
  58 //=== WS classes ===
  59
  60 /**
  61  * Mandatory interface for all test client classes.
  62  * @author Petr Skoda (skodak)
  63  */
  64 interface webservice_test_client_interface {
  65     /**
  66      * Execute test client WS request
  67      * @param string $serverurl
  68      * @param string $function
  69      * @param array $params
  70      * @return mixed
  71      */
  72     public function simpletest($serverurl, $function, $params);
  73 }
  74
  75 /**
  76  * Mandatory interface for all web service protocol classes
  77  * @author Petr Skoda (skodak)
  78  */
  79 interface webservice_server_interface {
  80     /**
  81      * Process request from client.
  82      * @return void
  83      */
  84     public function run();
  85 }
  86
  87 /**
  88  * Abstract web service base class.
  89  * @author Petr Skoda (skodak)
  90  */
  91 abstract class webservice_server implements webservice_server_interface {
  92
  93     /** @property string $wsname name of the web server plugin */
  94     protected $wsname = null;
  95
  96     /** @property string $username name of local user */
  97     protected $username = null;
  98
  99     /** @property string $password password of the local user */
 100     protected $password = null;
 101
 102     /** @property int $userid the local user */
 103     protected $userid = null;
 104
 105     /** @property bool $simple true if simple auth used */
 106     protected $simple;
 107
 108     /** @property string $token authentication token*/
 109     protected $token = null;
 110
 111     /** @property object restricted context */
 112     protected $restricted_context;
 113
 114     /** @property int restrict call to one service id*/
 115     protected $restricted_serviceid = null;
 116
 117     /**
 118      * Authenticate user using username+password or token.
 119      * This function sets up $USER global.
 120      * It is safe to use has_capability() after this.
 121      * This method also verifies user is allowed to use this
 122      * server.
 123      * @return void
 124      */
 125     protected function authenticate_user() {
 126         global $CFG, $DB;
 127
 128         if (!NO_MOODLE_COOKIES) {
 129             throw new coding_exception('Cookies must be disabled in WS servers!');
 130         }
 131
 132         if ($this->simple) {
 133
 134             //we check that authentication plugin is enabled
 135             //it is only required by simple authentication
 136             if (!is_enabled_auth('webservice')) {
 137                 throw new webservice_access_exception(get_string('wsauthnotenabled', 'webservice'));
 138             }
 139
 140             if (!$auth = get_auth_plugin('webservice')) {
 141                 throw new webservice_access_exception(get_string('wsauthmissing', 'webservice'));
 142             }
 143
 144             $this->restricted_context = get_context_instance(CONTEXT_SYSTEM);
 145
 146             if (!$this->username) {
 147                 throw new webservice_access_exception(get_string('missingusername', 'webservice'));
 148             }
 149
 150             if (!$this->password) {
 151                 throw new webservice_access_exception(get_string('missingpassword', 'webservice'));
 152             }
 153
 154             if (!$auth->user_login_webservice($this->username, $this->password)) {
 155                 // log failed login attempts
 156                 add_to_log(1, 'webservice', get_string('simpleauthlog', 'webservice'), '' , get_string('failedtolog', 'webservice').": ".$this->username."/".$this->password." - ".getremoteaddr() , 0);
 157                 throw new webservice_access_exception(get_string('wrongusernamepassword', 'webservice'));
 158             }
 159
 160             $user = $DB->get_record('user', array('username'=>$this->username, 'mnethostid'=>$CFG->mnet_localhost_id, 'deleted'=>0), '*', MUST_EXIST);
 161
 162         } else {
 163             if (!$token = $DB->get_record('external_tokens', array('token'=>$this->token, 'tokentype'=>EXTERNAL_TOKEN_PERMANENT))) {
 164                 // log failed login attempts
 165                 add_to_log(1, 'webservice', get_string('tokenauthlog', 'webservice'), '' , get_string('failedtolog', 'webservice').": ".$this->token. " - ".getremoteaddr() , 0);
 166                 throw new webservice_access_exception(get_string('invalidtoken', 'webservice'));
 167             }
 168
 169             if ($token->validuntil and $token->validuntil < time()) {
 170                 throw new webservice_access_exception(get_string('invalidtimedtoken', 'webservice'));
 171             }
 172
 173             if ($token->iprestriction and !address_in_subnet(getremoteaddr(), $token->iprestriction)) {
 174                 add_to_log(1, 'webservice', get_string('tokenauthlog', 'webservice'), '' , get_string('failedtolog', 'webservice').": ".getremoteaddr() , 0);
 175                 throw new webservice_access_exception(get_string('invalidiptoken', 'webservice'));
 176             }
 177
 178             $this->restricted_context = get_context_instance_by_id($token->contextid);
 179             $this->restricted_serviceid = $token->externalserviceid;
 180
 181             $user = $DB->get_record('user', array('id'=>$token->userid, 'deleted'=>0), '*', MUST_EXIST);
 182
 183             // log token access
 184             $DB->set_field('external_tokens', 'lastaccess', time(), array('id'=>$token->id));
 185         }
 186
 187         // now fake user login, the session is completely empty too
 188         session_set_user($user);
 189         $this->userid = $user->id;
 190
 191         if (!has_capability("webservice/$this->wsname:use", $this->restricted_context)) {
 192             throw new webservice_access_exception(get_string('accessnotallowed', 'webservice'));
 193         }
 194
 195         external_api::set_context_restriction($this->restricted_context);
 196     }
 197 }
 198
 199 /**
 200  * Special abstraction of our srvices that allows
 201  * interaction with stock Zend ws servers.
 202  * @author Petr Skoda (skodak)
 203  */
 204 abstract class webservice_zend_server extends webservice_server {
 205
 206     /** @property string name of the zend server class : Zend_XmlRpc_Server, Zend_Soap_Server, Zend_Soap_AutoDiscover, ...*/
 207     protected $zend_class;
 208
 209     /** @property object Zend server instance */
 210     protected $zend_server;
 211
 212     /** @property string $service_class virtual web service class with all functions user name execute, created on the fly */
 213     protected $service_class;
 214
 215     /**
 216      * Contructor
 217      * @param bool $simple use simple authentication
 218      */
 219     public function __construct($simple, $zend_class) {
 220         $this->simple = $simple;
 221         $this->zend_class = $zend_class;
 222     }
 223
 224     /**
 225      * Process request from client.
 226      * @param bool $simple use simple authentication
 227      * @return void
 228      */
 229     public function run() {
 230         // we will probably need a lot of memory in some functions
 231         @raise_memory_limit('128M');
 232
 233         // set some longer timeout, this script is not sending any output,
 234         // this means we need to manually extend the timeout operations
 235         // that need longer time to finish
 236         external_api::set_timeout();
 237
 238         // now create the instance of zend server
 239         $this->init_zend_server();
 240
 241         // set up exception handler first, we want to sent them back in correct format that
 242         // the other system understands
 243         // we do not need to call the original default handler because this ws handler does everything
 244         set_exception_handler(array($this, 'exception_handler'));
 245
 246         // init all properties from the request data
 247         $this->parse_request();
 248
 249         // this sets up $USER and $SESSION and context restrictions
 250         $this->authenticate_user();
 251
 252         // make a list of all functions user is allowed to excecute
 253         $this->init_service_class();
 254
 255         // tell server what functions are available
 256         $this->zend_server->setClass($this->service_class);
 257
 258         //log the web service request
 259         add_to_log(1, 'webservice', '', '' , $this->zend_class." ".getremoteaddr() , 0, $this->userid);
 260
 261         // execute and return response, this sends some headers too
 262         $response = $this->zend_server->handle();
 263
 264         // session cleanup
 265         $this->session_cleanup();
 266
 267         //finally send the result
 268         $this->send_headers();
 269         echo $response;
 270         die;
 271     }
 272
 273     /**
 274      * Load virtual class needed for Zend api
 275      * @return void
 276      */
 277     protected function init_service_class() {
 278         global $USER, $DB;
 279
 280         // first ofall get a complete list of services user is allowed to access
 281
 282         if ($this->restricted_serviceid) {
 283             $params = array('sid1'=>$this->restricted_serviceid, 'sid2'=>$this->restricted_serviceid);
 284             $wscond1 = 'AND s.id = :sid1';
 285             $wscond2 = 'AND s.id = :sid2';
 286         } else {
 287             $params = array();
 288             $wscond1 = '';
 289             $wscond2 = '';
 290         }
 291
 292         // now make sure the function is listed in at least one service user is allowed to use
 293         // allow access only if:
 294         //  1/ entry in the external_services_users table if required
 295         //  2/ validuntil not reached
 296         //  3/ has capability if specified in service desc
 297         //  4/ iprestriction
 298
 299         $sql = "SELECT s.*, NULL AS iprestriction
 300                   FROM {external_services} s
 301                   JOIN {external_services_functions} sf ON (sf.externalserviceid = s.id AND s.restrictedusers = 0)
 302                  WHERE s.enabled = 1 $wscond1
 303
 304                  UNION
 305
 306                 SELECT s.*, su.iprestriction
 307                   FROM {external_services} s
 308                   JOIN {external_services_functions} sf ON (sf.externalserviceid = s.id AND s.restrictedusers = 1)
 309                   JOIN {external_services_users} su ON (su.externalserviceid = s.id AND su.userid = :userid)
 310                  WHERE s.enabled = 1 AND su.validuntil IS NULL OR su.validuntil < :now $wscond2";
 311
 312         $params = array_merge($params, array('userid'=>$USER->id, 'now'=>time()));
 313
 314         $serviceids = array();
 315         $rs = $DB->get_recordset_sql($sql, $params);
 316
 317         // now make sure user may access at least one service
 318         $remoteaddr = getremoteaddr();
 319         $allowed = false;
 320         foreach ($rs as $service) {
 321             if (isset($serviceids[$service->id])) {
 322                 continue;
 323             }
 324             if ($service->requiredcapability and !has_capability($service->requiredcapability, $this->restricted_context)) {
 325                 continue; // cap required, sorry
 326             }
 327             if ($service->iprestriction and !address_in_subnet($remoteaddr, $service->iprestriction)) {
 328                 continue; // wrong request source ip, sorry
 329             }
 330             $serviceids[$service->id] = $service->id;
 331         }
 332         $rs->close();
 333
 334         // now get the list of all functions
 335         if ($serviceids) {
 336             list($serviceids, $params) = $DB->get_in_or_equal($serviceids);
 337             $sql = "SELECT f.*
 338                       FROM {external_functions} f
 339                      WHERE f.name IN (SELECT sf.functionname
 340                                         FROM {external_services_functions} sf
 341                                        WHERE sf.externalserviceid $serviceids)";
 342             $functions = $DB->get_records_sql($sql, $params);
 343         } else {
 344             $functions = array();
 345         }
 346
 347         // now make the virtual WS class with all the fuctions for this particular user
 348         $methods = '';
 349         foreach ($functions as $function) {
 350             $methods .= $this->get_virtual_method_code($function);
 351         }
 352
 353         // let's use unique class name, there might be problem in unit tests
 354         $classname = 'webservices_virtual_class_000000';
 355         while(class_exists($classname)) {
 356             $classname++;
 357         }
 358
 359         $code = '
 360 /**
 361  * Virtual class web services for user id '.$USER->id.' in context '.$this->restricted_context->id.'.
 362  */
 363 class '.$classname.' {
 364 '.$methods.'
 365 }
 366 ';
 367
 368         // load the virtual class definition into memory
 369         eval($code);
 370         $this->service_class = $classname;
 371     }
 372
 373     /**
 374      * returns virtual method code
 375      * @param object $function
 376      * @return string PHP code
 377      */
 378     protected function get_virtual_method_code($function) {
 379         global $CFG;
 380
 381         $function = external_function_info($function);
 382
 383         $params      = array();
 384         $params_desc = array();
 385         foreach ($function->parameters_desc->keys as $name=>$keydesc) {
 386             $param = '$'.$name;
 387             //need to generate the default if there is any
 388             if ($keydesc instanceof external_value) {
 389                 if ($keydesc->required == VALUE_DEFAULT) {
 390                     if ($keydesc->default===null) {
 391                         $param .= '=null';
 392                     } else {
 393                         switch($keydesc->type) {
 394                             case PARAM_BOOL:
 395                                 $param .= $keydesc->default; break;
 396                             case PARAM_INT:
 397                                 $param .= $keydesc->default; break;
 398                             case PARAM_FLOAT;
 399                                 $param .= $keydesc->default; break;
 400                             default:
 401                                 $param .= '=\''.$keydesc->default.'\'';
 402                         }
 403                     }
 404                 } else if ($keydesc->required == VALUE_OPTIONAL) {
 405                     //it does make sens to declare a parameter VALUE_OPTIONAL
 406                     //VALUE_OPTIONAL is used only for array/object key
 407                     throw new moodle_exception('parametercannotbevalueoptional');
 408                 }
 409             } else { //for the moment we do not support default for other structure types
 410                  if ($keydesc->required == VALUE_OPTIONAL or $keydesc->required == VALUE_DEFAULT) {
 411                      throw new moodle_exception('paramdefaultarraynotsupported');
 412                  }
 413             }
 414             $params[]      = $param;
 415             $type = 'string';
 416             if ($keydesc instanceof external_value) {
 417                 switch($keydesc->type) {
 418                     case PARAM_BOOL: // 0 or 1 only for now
 419                     case PARAM_INT:
 420                         $type = 'int'; break;
 421                     case PARAM_FLOAT;
 422                         $type = 'double'; break;
 423                     default:
 424                         $type = 'string';
 425                 }
 426             } else if ($keydesc instanceof external_single_structure) {
 427                 $type = 'struct';
 428             } else if ($keydesc instanceof external_multiple_structure) {
 429                 $type = 'array';
 430             }
 431             $params_desc[] = '     * @param '.$type.' $'.$name.' '.$keydesc->desc;
 432         }
 433         $params      = implode(', ', $params);
 434         $params_desc = implode("\n", $params_desc);
 435
 436         $serviceclassmethodbody = $this->service_class_method_body($function, $params);
 437
 438         if (is_null($function->returns_desc)) {
 439             $return = '     * @return void';
 440         } else {
 441             $type = 'string';
 442             if ($function->returns_desc instanceof external_value) {
 443                 switch($function->returns_desc->type) {
 444                     case PARAM_BOOL: // 0 or 1 only for now
 445                     case PARAM_INT:
 446                         $type = 'int'; break;
 447                     case PARAM_FLOAT;
 448                         $type = 'double'; break;
 449                     default:
 450                         $type = 'string';
 451                 }
 452             } else if ($function->returns_desc instanceof external_single_structure) {
 453                 $type = 'struct';
 454             } else if ($function->returns_desc instanceof external_multiple_structure) {
 455                 $type = 'array';
 456             }
 457             $return = '     * @return '.$type.' '.$function->returns_desc->desc;
 458         }
 459
 460         // now crate the virtual method that calls the ext implementation
 461
 462         $code = '
 463     /**
 464      * '.$function->description.'
 465      *
 466 '.$params_desc.'
 467 '.$return.'
 468      */
 469     public function '.$function->name.'('.$params.') {
 470 '.$serviceclassmethodbody.'
 471     }
 472 ';
 473         return $code;
 474     }
 475
 476     /**
 477      * You can override this function in your child class to add extra code into the dynamically
 478      * created service class. For example it is used in the amf server to cast types of parameters and to
 479      * cast the return value to the types as specified in the return value description.
 480      * @param unknown_type $function
 481      * @param unknown_type $params
 482      * @return string body of the method for $function ie. everything within the {} of the method declaration.
 483      */
 484     protected function service_class_method_body($function, $params){
 485         $descriptionmethod = $function->methodname.'_returns()';
 486         $callforreturnvaluedesc = $function->classname.'::'.$descriptionmethod;
 487         return '    if ('.$callforreturnvaluedesc.' == null)  {
 488                         return null;
 489                     }
 490                     return external_api::clean_returnvalue('.$callforreturnvaluedesc.', '.$function->classname.'::'.$function->methodname.'('.$params.'));';
 491     }
 492
 493     /**
 494      * Set up zend service class
 495      * @return void
 496      */
 497     protected function init_zend_server() {
 498         $this->zend_server = new $this->zend_class();
 499     }
 500
 501     /**
 502      * This method parses the $_REQUEST superglobal and looks for
 503      * the following information:
 504      *  1/ user authentication - username+password or token (wsusername, wspassword and wstoken parameters)
 505      *
 506      * @return void
 507      */
 508     protected function parse_request() {
 509         if ($this->simple) {
 510             //note: some clients have problems with entity encoding :-(
 511             if (isset($_REQUEST['wsusername'])) {
 512                 $this->username = $_REQUEST['wsusername'];
 513             }
 514             if (isset($_REQUEST['wspassword'])) {
 515                 $this->password = $_REQUEST['wspassword'];
 516             }
 517         } else {
 518             if (isset($_REQUEST['wstoken'])) {
 519                 $this->token = $_REQUEST['wstoken'];
 520             }
 521         }
 522     }
 523
 524     /**
 525      * Internal implementation - sending of page headers.
 526      * @return void
 527      */
 528     protected function send_headers() {
 529         header('Cache-Control: private, must-revalidate, pre-check=0, post-check=0, max-age=0');
 530         header('Expires: '. gmdate('D, d M Y H:i:s', 0) .' GMT');
 531         header('Pragma: no-cache');
 532         header('Accept-Ranges: none');
 533     }
 534
 535     /**
 536      * Specialised exception handler, we can not use the standard one because
 537      * it can not just print html to output.
 538      *
 539      * @param exception $ex
 540      * @return void does not return
 541      */
 542     public function exception_handler($ex) {
 543         // detect active db transactions, rollback and log as error
 544         abort_all_db_transactions();
 545
 546         // some hacks might need a cleanup hook
 547         $this->session_cleanup($ex);
 548
 549         // now let the plugin send the exception to client
 550         $this->send_error($ex);
 551
 552         // not much else we can do now, add some logging later
 553         exit(1);
 554     }
 555
 556     /**
 557      * Send the error information to the WS client
 558      * formatted as XML document.
 559      * @param exception $ex
 560      * @return void
 561      */
 562     protected function send_error($ex=null) {
 563         $this->send_headers();
 564         echo $this->zend_server->fault($ex);
 565     }
 566
 567     /**
 568      * Future hook needed for emulated sessions.
 569      * @param exception $exception null means normal termination, $exception received when WS call failed
 570      * @return void
 571      */
 572     protected function session_cleanup($exception=null) {
 573         if ($this->simple) {
 574             // nothing needs to be done, there is no persistent session
 575         } else {
 576             // close emulated session if used
 577         }
 578     }
 579
 580 }
 581
 582 /**
 583  * Web Service server base class, this class handles both
 584  * simple and token authentication.
 585  * @author Petr Skoda (skodak)
 586  */
 587 abstract class webservice_base_server extends webservice_server {
 588
 589     /** @property array $parameters the function parameters - the real values submitted in the request */
 590     protected $parameters = null;
 591
 592     /** @property string $functionname the name of the function that is executed */
 593     protected $functionname = null;
 594
 595     /** @property object $function full function description */
 596     protected $function = null;
 597
 598     /** @property mixed $returns function return value */
 599     protected $returns = null;
 600
 601     /**
 602      * Contructor
 603      * @param bool $simple use simple authentication
 604      */
 605     public function __construct($simple) {
 606         $this->simple = $simple;
 607     }
 608
 609     /**
 610      * This method parses the request input, it needs to get:
 611      *  1/ user authentication - username+password or token
 612      *  2/ function name
 613      *  3/ function parameters
 614      *
 615      * @return void
 616      */
 617     abstract protected function parse_request();
 618
 619     /**
 620      * Send the result of function call to the WS client.
 621      * @return void
 622      */
 623     abstract protected function send_response();
 624
 625     /**
 626      * Send the error information to the WS client.
 627      * @param exception $ex
 628      * @return void
 629      */
 630     abstract protected function send_error($ex=null);
 631
 632     /**
 633      * Process request from client.
 634      * @return void
 635      */
 636     public function run() {
 637         // we will probably need a lot of memory in some functions
 638         @raise_memory_limit('128M');
 639
 640         // set some longer timeout, this script is not sending any output,
 641         // this means we need to manually extend the timeout operations
 642         // that need longer time to finish
 643         external_api::set_timeout();
 644
 645         // set up exception handler first, we want to sent them back in correct format that
 646         // the other system understands
 647         // we do not need to call the original default handler because this ws handler does everything
 648         set_exception_handler(array($this, 'exception_handler'));
 649
 650         // init all properties from the request data
 651         $this->parse_request();
 652
 653         // authenticate user, this has to be done after the request parsing
 654         // this also sets up $USER and $SESSION
 655         $this->authenticate_user();
 656
 657         // find all needed function info and make sure user may actually execute the function
 658         $this->load_function_info();
 659
 660         //log the web service request
 661         add_to_log(1, 'webservice', $this->functionname, '' , getremoteaddr() , 0, $this->userid);
 662
 663         // finally, execute the function - any errors are catched by the default exception handler
 664         $this->execute();
 665
 666         // send the results back in correct format
 667         $this->send_response();
 668
 669         // session cleanup
 670         $this->session_cleanup();
 671
 672         die;
 673     }
 674
 675     /**
 676      * Specialised exception handler, we can not use the standard one because
 677      * it can not just print html to output.
 678      *
 679      * @param exception $ex
 680      * @return void does not return
 681      */
 682     public function exception_handler($ex) {
 683         // detect active db transactions, rollback and log as error
 684         abort_all_db_transactions();
 685
 686         // some hacks might need a cleanup hook
 687         $this->session_cleanup($ex);
 688
 689         // now let the plugin send the exception to client
 690         $this->send_error($ex);
 691
 692         // not much else we can do now, add some logging later
 693         exit(1);
 694     }
 695
 696     /**
 697      * Future hook needed for emulated sessions.
 698      * @param exception $exception null means normal termination, $exception received when WS call failed
 699      * @return void
 700      */
 701     protected function session_cleanup($exception=null) {
 702         if ($this->simple) {
 703             // nothing needs to be done, there is no persistent session
 704         } else {
 705             // close emulated session if used
 706         }
 707     }
 708
 709     /**
 710      * Fetches the function description from database,
 711      * verifies user is allowed to use this function and
 712      * loads all paremeters and return descriptions.
 713      * @return void
 714      */
 715     protected function load_function_info() {
 716         global $DB, $USER, $CFG;
 717
 718         if (empty($this->functionname)) {
 719             throw new invalid_parameter_exception('Missing function name');
 720         }
 721
 722         // function must exist
 723         $function = external_function_info($this->functionname);
 724
 725         if ($this->restricted_serviceid) {
 726             $params = array('sid1'=>$this->restricted_serviceid, 'sid2'=>$this->restricted_serviceid);
 727             $wscond1 = 'AND s.id = :sid1';
 728             $wscond2 = 'AND s.id = :sid2';
 729         } else {
 730             $params = array();
 731             $wscond1 = '';
 732             $wscond2 = '';
 733         }
 734
 735         // now let's verify access control
 736
 737         // now make sure the function is listed in at least one service user is allowed to use
 738         // allow access only if:
 739         //  1/ entry in the external_services_users table if required
 740         //  2/ validuntil not reached
 741         //  3/ has capability if specified in service desc
 742         //  4/ iprestriction
 743
 744         $sql = "SELECT s.*, NULL AS iprestriction
 745                   FROM {external_services} s
 746                   JOIN {external_services_functions} sf ON (sf.externalserviceid = s.id AND s.restrictedusers = 0 AND sf.functionname = :name1)
 747                  WHERE s.enabled = 1 $wscond1
 748
 749                  UNION
 750
 751                 SELECT s.*, su.iprestriction
 752                   FROM {external_services} s
 753                   JOIN {external_services_functions} sf ON (sf.externalserviceid = s.id AND s.restrictedusers = 1 AND sf.functionname = :name2)
 754                   JOIN {external_services_users} su ON (su.externalserviceid = s.id AND su.userid = :userid)
 755                  WHERE s.enabled = 1 AND su.validuntil IS NULL OR su.validuntil < :now $wscond2";
 756         $params = array_merge($params, array('userid'=>$USER->id, 'name1'=>$function->name, 'name2'=>$function->name, 'now'=>time()));
 757
 758         $rs = $DB->get_recordset_sql($sql, $params);
 759         // now make sure user may access at least one service
 760         $remoteaddr = getremoteaddr();
 761         $allowed = false;
 762         foreach ($rs as $service) {
 763             if ($service->requiredcapability and !has_capability($service->requiredcapability, $this->restricted_context)) {
 764                 continue; // cap required, sorry
 765             }
 766             if ($service->iprestriction and !address_in_subnet($remoteaddr, $service->iprestriction)) {
 767                 continue; // wrong request source ip, sorry
 768             }
 769             $allowed = true;
 770             break; // one service is enough, no need to continue
 771         }
 772         $rs->close();
 773         if (!$allowed) {
 774             throw new webservice_access_exception('Access to external function not allowed');
 775         }
 776
 777         // we have all we need now
 778         $this->function = $function;
 779     }
 780
 781     /**
 782      * Execute previously loaded function using parameters parsed from the request data.
 783      * @return void
 784      */
 785     protected function execute() {
 786         // validate params, this also sorts the params properly, we need the correct order in the next part
 787         $params = call_user_func(array($this->function->classname, 'validate_parameters'), $this->function->parameters_desc, $this->parameters);
 788
 789         // execute - yay!
 790         $this->returns = call_user_func_array(array($this->function->classname, $this->function->methodname), array_values($params));
 791     }
 792 }
 793
 794