<?php
//
//=========================================================
// DepotServer.php  Implements a Perforce WebDAV server
//=========================================================
// +----------------------------------------------------------------------+
// | PHP Version 4 and 5                                                  |
// | Original Name = FileSystem.php                                       |
// +----------------------------------------------------------------------+
// | Author: Daniel Sabsay <danielsabsay@pacbell.net>                     |
// |                                                                      |
// | Based on a model by: Hartmut Holzgraefe <hholzgra@php.net>           |
// |                      Christian Stocker <chregu@bitflux.ch>           |
// +----------------------------------------------------------------------+
//
  require_once realpath('.').'/DAVServer.php';
  define ('CR',"\n");
  define ('DIRR','httpd/unix-directory');
  define ('DIRP','DavDirectoryPlaceholder');
  //  prohibited characters in file names: @ %40, # %23, * %2A, % %25
 
  /**
   * Perforce depot access using local p4 client
   *
   * @access public
   */
class Depot_Filesystem extends HTTP_WebDAV_Server
{
  /**
   * Root directory for WebDAV access
   *
   * @access private
   * @var    string
   */
  var $base = "";
 
  /**
   * Logging control: 0=none, 1=connection, 2=detail 3=debug
   *
   * @access private
   * @var    integer
   */
  var $logging = 0;
 
  /** 
   * Perforce Host connection parameters
   *
   * @access private
   * @var    string
   */
  var $depot_host = 'public.perforce.com';
  var $depot_port = '1666';
  var $depot_agent = '/usr/local/bin/p4';
 
  /**
   * Perforce user & password
   *
   * @access private
   * @var    string
   */
  var $depot_user;
  var $depot_passwd;
 
  /**
   * Perforce Admin user & password
   *
   * Used ONLY for the removal of placeholder files
   *  that force new directories to be "visible"
   *
   * @access private
   * @var    string
   */
  var $admin_user;
  var $admin_passwd;
 
  /**
   * Serve a webdav request
   *
   * @access public
   * @param  string  
   */
  function ServeRequest($method) 
  {                           
  // let the base class do all the work
    parent::ServeRequest($method);    
  }
 
  /**
   * PERFORCE USER AUTHORIZATION
   *
   * @access private
   * @return bool true on successful authentication
   */
  function _check_auth() 
  {
    if ($this->logging>2) {
      error_log('**Perforce P4 version='.$this->sp4cmd('-V','',''));
    }
    if (empty($_SERVER['PHP_AUTH_USER'])) return false;
    // Authenticate with the Perforce repository server
    $this->depot_user = $_SERVER['PHP_AUTH_USER'];
    $this->depot_passwd = $_SERVER['PHP_AUTH_PW'];
    $r = $this->sp4cmd('user','-o','');
    $p = strpos($r,'Password:'); // skip the pro-forma password
    // This second password label only appears if login was
    //   accepted by the Perforce repository.
    if (strpos(substr($r,$p+9),'Password:')) return true;
    $p4 = strpos($this->sp4cmd('-V','',''),'Perforce Software');
    if ($p4===false) error_log('**** P4 client module not found at '.$this->depot_agent);
    if ($this->logging>1) error_log('**Login error, user='.$this->depot_user);
    return false;
  } // end _check_auth
 
  /**
   * PROPFIND method handler
   *
   * @param  array  general parameter passing array
   * @param  array  return array for file properties
   * @return bool   true on success
   */
  function PROPFIND(&$options, &$files) 
  {
    $path = $options['path'];
    $p4path = '/'.$path;
    $datePat = array('date'=>'time ');
    $dirPat = array('path'=>'dir /');
    $depotPat = array('raw'=>'Depot ');
    $filePat = array('path'=>'depotFile /',
                    'size'=>'fileSize ',
                    'date'=>'headTime ');
    if ($p4path=='//') {
      $group['self'] = array(array('path'=>''));
      if (!empty($options['depth'])) { // skip if self only (depth==0)
        $group['depots'] = $this->p4list('depots','',$depotPat);
      }
    } else {
      if (substr($path,-1)=='/') {
        $is_dir = true; // Assume it's a  directory
        $path = substr($path,0,strlen($path)-1);  // drop trailing separator
        $p4path = '/'.$path;
      } else { // else might be a file
        $self_file = $this->p4list('fstat -Ol',$p4path,$filePat);
        if (empty($self_file)) { $is_dir = true; }
        else { $group['files'] = $self_file[0]; }
      }
      if ($is_dir) { // Not a file, probably a directory
        $c_dirs = count($this->p4list('dirs -D',$p4path,$dirPat)); // dir exists?
        $c_dirs += count($this->p4list('depots','',array('x'=>'Depot '.basename($path))));
        if (!$c_dirs) { return false; } // none of the above, then doesn't exist
        if (strpos($options['depth'],'noroot')===false) { // Omit self ?
          $group['self'] = array(array('path'=>$path));
        }
        if (!empty($options['depth'])) { // skip if self only (depth==0)
          $group['dirs']=$this->p4list('dirs -D',$p4path.'/*',$dirPat);     
          // Deleted files are not shown because they do not exhibit a filesize
          //  attribute with the "Ol" option, and are therefore ignored by p4list.
          $group['files'] = $this->p4list('fstat -Ol',$p4path.'/*',$filePat);
          //$group['config']=array($path.'/**my_configuration**');
        }
      }
    }
    $files['files'] = array(); // initialize item stack
    foreach ($group as $group_type=>$children) {
      foreach ($children as $child) {
        switch ($group_type) {
        case 'depots':
          $child['path'] = '/'.substr($child['raw'],0,strpos($child['raw'],' '));
          // fall thru
        case 'dirs':
          $p4subDirs = '/'.$child['path'].'/*';
          $lastMod = $this->p4list('changes -m1',$p4subDirs,$datePat);
          $child['date'] = $lastMod[0]['date'];
          // fall thru
        case 'self':
          $child['name'] = basename($child['path']);
          $child['path'] .= '/'; // sub-directories get trailing separator
          $child['rez'] = 'collection';
          $child['type'] = DIRR;
          break;
        case 'files':
          $child['name'] = basename($child['path']);
          $child['type'] = $this->_mimetype($child['path']);
        }
        if ($child['name'] == DIRP) continue; // ignore any placeholder leakage
        $props = array(); // initialize property array
        array_push($props,$this->mkprop('getcontentlength',$child['size']));
        array_push($props,$this->mkprop('resourcetype',$child['rez']));
        array_push($props,$this->mkprop('getcontenttype',$child['type']));
        array_push($props,$this->mkprop('displayname',$child['name']));
        array_push($props,$this->mkprop('getlastmodified',$child['date']));
        array_push($props,$this->mkprop('creationdate',0));
        // Summarize properties for this item
        array_push($files['files'],array('path'=>$child['path'],'props'=>$props));
      }
    }
  return true;
  } // end PROPFIND
 
 
  /**
   * try to detect the mime type of a file
   *
   * @param  string  file path
   * @return string  guessed mime type
   */
  function _mimetype($path) 
  {
    // Fallback solution: try to guess the type by the file extension
    // TODO: add more ...
    // TODO: it has been suggested to delegate mimetype detection 
    //       to apache but this has at least three issues:
    //       - works only with apache
    //       - needs file to be within the document tree
    //       - requires apache mod_magic 
    // TODO: can we use the registry for this on Windows?
    //       OTOH if the server is Windos the clients are likely to 
    //       be Windows, too, and tend do ignore the Content-Type
    //       anyway (overriding it with information taken from
    //       the registry)
    // TODO: have a seperate PEAR class for mimetype detection?
      switch (strtolower(strrchr(basename($path), "."))) {
      case ".html":
          $mime_type = "text/html";
          break;
      case ".gif":
          $mime_type = "image/gif";
          break;
      case ".jpg":
          $mime_type = "image/jpeg";
          break;
      case ".png":
          $mime_type = "image/png";
          break;
      case ".txt":
          $mime_type = "text/plain";
          break;
      case ".xml":
          $mime_type = "text/xml";
          break;
      case ".php":
          $mime_type = "text/php";
          break;
      default: 
          $mime_type = "application/octet-stream";
          break;
      }
    return $mime_type;
  }
 
  /**
   * GET method handler
   * 
   * @param  array  parameter passing array
   * @return bool   true on success
   */
  function GET(&$options) 
  {
    $path = $options['path'];
    $p4dir = '/'.dirname($path);
    $node = basename($path);
    $p4path = $p4dir.'/'.$node; // drop possible trailing separator
    $fileAPat = array('path'=>'depotFile /','action'=>'action ','date'=>'time ');
    $exists = $this->p4list('files',$p4path,$fileAPat);
    if (empty($exists)) return false;
    if ($exists[0]['action']=='delete') return false;
    $mod_date = $exists[0]['date'];
    header('Accept-Ranges: bytes');
    header('ETag: "'.uniqid('E').'"');
    $mod_since = $hdrs['If-Modified-Since'];
    if ($mod_since) {
      if (strtotime($mod_since) >= $mod_date) return '304 Not Modified';
    }
    $file = $this->base.uniqid('F'); // Generate temporary filename
    $this->sp4cmd('print -q -o '.$file,'"'.$p4path.'"',''); // read data from depot
    $options['mimetype'] = $this->_mimetype($path);
    $options['mtime'] = $mod_date;
    $options['size'] = filesize($file);
    $fr = fopen($file,'r');
    $fail = !$fr;
    if ($fail) {
      error_log('*** Filesystem permission error ***');
      unlink($file);
    } else {
      $options['stream'] = $fr; // Open stream to temp file
      $options['delete_path'] = $file; // Mark temp for disposal
    }
    return ($fail)? false:true;
  } // end GET
  
  function HEAD(&$params) 
   {
    $status = $this->GET($params);
    if ($status===false) return false;
    header('Content-Length: '.$params['size']);
    fclose($params['stream']);
    unlink($params['delete_path']);
    return $status;
   } // end HEAD
  
  /**
   * PUT method handler
   * 
   * @param  array  parameter passing array
   * @return bool   true on success
   */
  function PUT(&$options) 
  {
    $path = $options['path'];
    $p4dir = '/'.dirname($path);
    $node = basename($path);
    $p4path = $p4dir.'/'.$node; // drop possible trailing separator
    if ($p4path=='//') return '403 Forbidden, cannot make depot';
    $uid = uniqid('');
    $ws_id = 'W'.$uid;
    $dir = $this->base.'D'.$uid; // temp filesystem directory name
    // Create a temporary private directory on the server
    $fail = (mkdir($dir)===false); // make temp directory
    if (!$fail) { // connect to HTTP data stream
      $fr = $options['stream'];
      $fail = ($fr===false);
    }
    if (!$fail) { // open temp file for data
      $file = $dir.'/'.$node;
      $fw = fopen($file,'w');
      $fail = ($fw===false);
    }
    if (!$fail) { // Copy file contents from the user's HTTP request
      while (!feof($fr)) fwrite($fw,fread($fr,4096));
      fclose($fr); fclose($fw);
    }
    if (!$fail) $fail = !$this->p4work($ws_id,$p4dir,$dir); // new workspace
    if (!$fail) $this->sp4cmd('flush','"'.$p4path.'"','-c '.$ws_id);
    if (!$fail) { // open for EDIT or ADD depending on current existence
      $filePatA = array('path'=>'depotFile /','action'=>'action ');
      $exists = $this->p4list('files',$p4path,$filePatA);
      if (empty($exists)) { $update = 'add'; }
      else { $update = ($exists[0]['action']=='delete')? 'add':'edit'; }
      $x = $this->sp4cmd($update,'"'.$p4path.'"','-c '.$ws_id);
      $fail = (strpos($x,'opened for')===false);
      if ($fail) error_log('***'.$update.' '.$x);
    } // SUBMIT the change
    if (!$fail) $fail = !$this->p4submit($ws_id,$update,$p4path);
    $this->sp4cmd('client','-d -f '.$ws_id,''); // release workspace
    if (!$fail) {
      if (!strpos($this->sp4cmd('files',$p4dir.'/'.DIRP,''),'no such')) {
        $this->p4faux_drop($p4dir); // remove faux dir placeholder if present
      }
    }
    unlink($file); // delete temp file
    rmdir($dir); // delete temp directory
    return ($fail)? false:true;
  }  // end PUT
 
  /**
   * MKCOL method handler
   *
   * @param  array  general parameter passing array
   * @return bool   true on success
   */
  function MKCOL($options) 
  {           
    $path = $options['path'];
    $p4dir = '/'.dirname($path);
    $p4path = $p4dir.'/'.basename($path); // drop possible trailing separator
    $uid = uniqid('');
    $ws_id = 'W'.$uid;
    $dir = $this->base.'D'.$uid; // temp filesystem directory name
    if ($p4path=='//') return '403 Forbidden, cannot make depot';
    // Parent directory must already exist
    if (count(split('/',$path))>3) { // Regular directory or depot?
      $exists = $this->p4list('dirs -D',$p4dir,array('x'=>'dir /'));
    } else {
      $exists = $this->p4list('depots','',array('x'=>'Depot '.substr(dirname($path),1)));
    }
    if (empty($exists)) return '403 Forbidden, no parent directory';
    // Directory with the same name must not already exist
    $exists = $this->p4list('files',$p4path,array('path'=>'dir /'));
    if (!empty($exists)) return '405 Not allowed, directory already exists';
    // File with the same name must not already exist   
    $exists = $this->p4list('files',$p4path,array('path'=>'depotFile /'));
    if (!empty($exists)) return '409 Conflict, file already exists';
    if (!empty($_SERVER['CONTENT_LENGTH'])) { // no body parsing yet
      return '415 Unsupported media type';
    }
 
    // Create a persistent empty (faux) directory by putting
    //   a "deleted" placeholder file inside.
    
    $fail = !$this->p4faux_make($p4path);
    return ($fail)? false:'201 Created';
  } // end MKCOL
  
  /**
   * DELETE method handler
   *
   * @param  array  general parameter passing array
   * @return bool   true on success
   */
    function DELETE($options) 
    {
    $path = $options['path'];
    $p4dir = '/'.dirname($path);
    if ($p4dir=='//') return '403 Forbidden, cannot delete depot.';
    $node = basename($path);
    $p4path = $p4dir.'/'.$node;
    // Create a temporary private directory in our filespace
    $uid = uniqid('');
    $ws_id = 'W'.$uid;
    $dir = $this->base.'D'.$uid; // temp filesystem directory name
    $fail = !mkdir($dir); // make temp directory
    if (!$fail) {
      $file = $dir.'/'.$node; // create temporary sacrificial
      $fail = !touch($file); //   file that P4 can delete
    }
    if (!$fail) { // Is item to delete an empty (faux) directory?
      if (!strpos($this->sp4cmd('files',$p4path.'/'.DIRP,''),'no such')) {
        $this->p4faux_drop($p4path); // yes, delete by removing placeholder
      } else { // no, must delete the actual file [or directory]
        $fail = !$this->p4work($ws_id,$p4dir,$dir); // attach workspace
        if (!$fail) {
          $this->sp4cmd('flush','"'.$p4path.'"','-c '.$ws_id);
          $x = $this->sp4cmd('delete','"'.$p4path.'"','-c '.$ws_id);
          $fail = (strpos($x,'opened for')===false);
        }
        if ($fail) error_log('***delete '.$x.$p4path);
        if (!$fail) $fail = !$this->p4submit($ws_id,'delete',$p4path);
      }
    }
    $this->sp4cmd('client','-d -f '.$ws_id,'');  // release workspace
    unlink($file); // delete temp file (should be redundant)
    rmdir($dir); // delete temp directory
    return ($fail)? '404 Not found-3':true;
  } // end DELETE
  
  /**
   * MOVE method handler
   *
   * @param  array  general parameter passing array
   * @return bool   true on success
   */
  function MOVE($options) 
  {
      return $this->COPY($options, true);
  } // end MOVE
 
  /**
   * COPY method handler
   *
   * @param  array  general parameter passing array
   * @return bool   true on success
   */
  function COPY($options, $del=false) 
  {
    // TODO Property updates still broken (Litmus should detect this?)
    $fileAPat = array('path'=>'depotFile /','action'=>'action ');
    
    if (!empty($_SERVER['CONTENT_LENGTH'])) { // no body parsing yet
      return '415 Unsupported media type';
    }
 
    // no copying to different WebDAV Servers yet
    if (isset($options['dest_url'])) {
      return '502 bad gateway';
    }
    $path = $options['path'];
    $p4dir = '/'.dirname($path);
    $node = basename($path);
    $p4src = $p4dir.'/'.$node; // drop possible trailing separator
    $fileAPat = array('path'=>'depotFile /','action'=>'action ');
    $file = $this->p4list('files',$p4src,$fileAPat);
    $dir = $this->p4list('dirs -D',$p4src,array('x'=>'dir '));
    $depot = $this->p4list('depots',$p4src,array('x'=>'Depot '));
    if (empty($file)&&empty($dir)&&empty($depot)) { return '404 Not found-1'; }
    else { if ($file[0]['action']=='delete') return '404 Not found-2'; }
    
    $dest = $options['dest'];
    $p4destDir = '/'.dirname($dest);
    $node = basename($dest);
    $p4dest = $p4destDir.'/'.$node; // drop possible trailing separator
    $exists = $this->p4list('files',$p4dest,$fileAPat);
    if (empty($exists)) { $new = true; }
    else { $new = ($exists[0]['action']=='delete')? true:false; }
    $dir = $this->p4list('dirs -D',$p4dest,array('x'=>'dir '));
    $existing_col = false;
    if (!$new) {
      if ($del && !empty($dir)) {
        if (!$options['overwrite']) return '412 precondition failed';
        $existing_col = true;
      }
    }
    if (!$new) {
      if ($options['overwrite']) {
        $stat = $this->DELETE(array('path'=>$dest));
        if (substr($stat,0,1) != '2') return $stat; 
      } else {                
        return '412 precondition failed';
      }
    }
    // Is the source a directory?
    $c_dir = count($this->p4list('dirs -D',$p4src,array('x'=>'dir ')));
    $c_dir += count($this->p4list('depots',$p4src,array('x'=>'Depot ')));
    if ($c_dir) {
      $dx = '/...';
      // RFC 2518 Section 9.2, last paragraph
      if ($options['depth'] != 'infinity') {
        error_log('--depth='.$options['depth']);
        return '400 Bad request';
      }
    } else {
      $dx = '';
    }
    // Create a temporary private directory on the server
    $uid = uniqid('');
    $ws_id = 'W'.$uid;
    $dir = $this->base.'D'.$uid; // temp filesystem directory name
    $fail = !mkdir($dir); // make temp directory
    $fail = !$this->p4work($ws_id,$p4destDir,$dir); // attach a workspace
    if (!$fail) { 
      $this->sp4cmd('flush','"'.$p4dest.'"','-c '.$ws_id);
      $x = $this->sp4cmd('integ -f -i -d','"'.$p4src.$dx.'" "'.$p4dest.$dx.'"','-c '.$ws_id);
      $fail = (strpos($x,'branch/sync')===false);
      if ($fail) error_log('***integrate '.$x);
    }
    if (!$fail) { 
      $x = $this->sp4cmd('resolve -at','"'.$p4dest.$dx.'"','-c '.$ws_id);
      $fail = (strpos($x,'resolve')===false);
      if ($fail) error_log('***resolve '.$x);
    }
    if (!$fail) $fail = !$this->p4submit($ws_id,'copy of '.$p4src,$p4dest);
    $this->sp4cmd('client','-d -f '.$ws_id,''); // release workspace
    // Check if this makes a faux directory non-empty
    if (!strpos($this->sp4cmd('files',$p4destDir.'/'.DIRP,''),'no such')) {
      $this->p4faux_drop($p4destDir); // yes, remove unnecessary placeholder
    }
    rmdir($dir); // delete temp directory
    
    if (!$fail) {
      if ($del) {
        $stat = $this->DELETE(array('path'=>$path));
        if (substr($stat,0,1) != '2') return $stat;
      }
    }
    return ($new && !$existing_col) ? "201 Created" : "204 No Content";         
  } // end COPY
 
  /**
   * PROPPATCH method handler
   *
   * @param  array  general parameter passing array
   * @return bool   true on success
   */
  function PROPPATCH(&$options) 
  {
    foreach($options['props'] as $key => $prop) {
      if($ns == 'DAV:') {
        $options['props'][$key]['status'] = '403 Forbidden';
      }
    }             
    return '';
  }
 
  /**
   * LOCK method handler
   *
   * @param  array  general parameter passing array
   * @return bool   true on success
   */
  function LOCK(&$options) 
  {
    if(isset($options['update'])) { // Lock Update          
    }
    
    $options['timeout'] = time()+1; // 1 second hardcoded
 
    return '200 OK';
  }
 
  /**
   * UNLOCK method handler
   *
   * @param  array  general parameter passing array
   * @return bool   true on success
   */
  function UNLOCK(&$options) 
  {
    return "200 OK";
  }
 
  /**
   * checkLock() helper
   *
   * @param  string resource path to check for locks
   * @return bool   true on success
   */
  function checkLock($path) 
  {
      // TODO
      return false;
  }
  /**
   * p4faux_make private method
   *
   * Create a persistent placeholder file that makes a persistent
   * empty (faux) directory visible.
   *
   * @param string  workspace name
   * @param string  Perforce directory path
   */ 
  function p4faux_make($p4dir) {
    $uid = uniqid('');
    $ws_id = 'W'.$uid;
    $dir = $this->base.'D'.$uid; // temp filesystem directory name
    $dummy = $dir.'/'.DIRP;
    $p4dummy = $p4dir.'/'.DIRP;
    $fail = !mkdir($dir);
    if (!$fail) touch($dummy); // make empty place-holder file
    $fail = !$this->p4work($ws_id,$p4dir,$dir); // attach workspace
    if (!$fail) {
      $this->sp4cmd('flush','"'.$p4dir.'"','-c '.$ws_id);
      $x = $this->sp4cmd('add','"'.$p4dummy.'"','-c '.$ws_id);
      $fail = (strpos($x,'assuming')===false);
      if (!$fail) $fail = !$this->p4submit($ws_id,'make directory',$p4dummy);
    }
    if (!$fail) {
      $this->sp4cmd('flush','"'.$p4dir.'"','-c '.$ws_id);
      $x = $this->sp4cmd('delete','"'.$p4dummy.'"','-c '.$ws_id);
      $fail = (strpos($x,'opened')===false);
    }
    if (!$fail) $fail = !$this->p4submit($ws_id,'delete directory placeholder',$p4dummy);
    $this->sp4cmd('client','-d -f '.$ws_id,''); // release workspace
    unlink($dummy); // delete temp file (should be redundant)
    rmdir($dir);
    return ($fail)? false:true;
  }
  function p4faux_drop($p4dir) { // Remove empty directory dummy placeholder file.
    $save_user = $this->depot_user; // save normal user
    $save_passwd = $this->depot_passwd; // save normal password
    $this->depot_user = $this->admin_user; // substitute Perforce superuser
    $this->depot_passwd = $this->admin_passwd; // and superuser password
    $this->sp4cmd('obliterate -y','"'.$p4dir.'/'.DIRP.'"',''); // remove placeholder
    $this->depot_user = $save_user; // restore normal user
    $this->depot_passwd = $save_passwd; // restore normal password
  }
  function p4submit($ws_id,$action,$p4path) { // SUBMIT change
    $change  = 'Change: new'.CR;
    $change .= 'Description:'.CR;
    $change .= ' DAV-'.$action.' by p4DAV/'.$this->depot_user.CR;
    $change .= 'Files:'.CR;
    $change .= '  '.$p4path;
    $x=shell_exec('echo \''.$change.'\' | '.$this->p4cmd('change -i','','-c '.$ws_id));
    $fail = (strpos($x,'created with')===false);
    if ($fail) { error_log('***change '.$x.' '.$change); }
    else {
      $cl_id = substr(substr($x,0,strpos($x,' created')),7);
      $x = $this->sp4cmd('submit','-c '.$cl_id,'-c '.$ws_id);
      $fail = (strpos($x,'submitted')===false);
      if ($fail) error_log('***submit '.$x);
    }
    return ($fail)? false:true;
  }
  function p4work($ws_id,$p4dir,$fsdir) {
    $view  = 'Client:  '.$ws_id.CR;
    $view .= 'Owner:  '.$this->depot_user.CR;
    $view .= 'Options:  allwrite noclobber nocompress unlocked nomodtime normdir'.CR;
    $view .= 'LineEnd:  local'.CR;
    $view .= 'Root:  '.$fsdir.CR;
    $view .= 'View:  '.CR;
    $view .= '  "'.$p4dir.'/..."  "//'.$ws_id.'/..."';
    $x = shell_exec('echo \''.$view.'\' | '.$this->p4cmd('client -i','',''));
    $fail = (strpos($x,'saved')===false);
    if ($fail) error_log('***workspace '.$x.' '.$view);
    return ($fail)? false:true;
  }
  function p4cmd($cmd,$path,$gopts) {
    $p4cmd  = $this->depot_agent.' '.$gopts;
    $p4cmd .=' -u '.$this->depot_user;
    $p4cmd .=' -P '.$this->depot_passwd;
    $p4cmd .=' -p '.$this->depot_host.':'.$this->depot_port;
    $p4cmd .=' '.$cmd.' '.$path.' 2>&1';
    return $p4cmd;
  }
  function p4list($cmd,$path,$filters) {
    $quoted_path = (empty($path))? '':'"'.$path.'"';
    $data_lines = split(CR,$this->sp4cmd($cmd,$quoted_path,'-ztag'));
    $responses = array();
    $filter_count = count($filters);
    $hits = 0;
    $matches = array();
    foreach ($data_lines as $item) {
    if ($this->logging>2) error_log('**'.$item);
      if (empty($item)) { $hits=0; $matches=array(); continue; }
      foreach ($filters as $key=>$pattern) {
        $skip = strlen($pattern);
        $pos = strpos($item,$pattern);
        if ($pos===false) continue;
        $hits++;
        $matches[$key]=trim(substr($item,$pos+$skip));
      }
      if ($filter_count<=$hits) { $hits=0; array_push($responses,$matches); }
    }
    return $responses;
  }
  function sp4cmd($a,$b,$c) { return shell_exec($this->p4cmd($a,$b,$c)); }
}
?>