/** Require the http module. */
var http = require('http');
 
/** Create a new http server to listen to and send requsts from. */
var server = http.createServer(function(req, res) {
    res.writeHead(200, {'Content-Type':'text/html'});
    res.end();
});
server.listen(12121);
 
/** Require the socket.io module */
var io = require('socket.io').listen(server);
 
/** File system library **/
var fs = require('fs');
 
/** Extract the session id from the headers cookies **/
function getPHPSessionId(cookies) {
    var phpSessionId = '';
    cookies.split(';').forEach(function(a) {
        var b = a.split('=');
        if(b[0].trim() == 'PHPSESSID') {
            phpSessionId = b[1].trim();
        }
    });
 
    return phpSessionId;
}
 
/**
 * This function will look in the PHP Session directory and look for the session
 * file.  If the file exists it will load that file as a string and then parse
 * that string for the PHP Session which will only be stored once the PHP authorization
 * method saves it.
 */
function authorizePHPSession(phpSessionId, cb) {
    try {
        fs.readFile('/path/to/sessions/sess_'+phpSessionId, 'utf8', function(err, data) {
            if(err) {
                throw err;
            }
 
            if(data.search(phpSessionId.toString()) > -1) {
                cb(null, true);
            } else {
                cb(null, false);
            }
        });
    } catch(e) {
        cb(null, false);
    }
}
 
io.configure(function() {
    io.set('transports', ['xhr-polling','htmlfile','jsonp-polling']);
    io.set('authorization', function (data, cb) {
        authorizePHPSession(getPHPSessionId(data.headers.cookie), cb);
    });
});

io.configure(function() {
    io.set('transports', ['xhr-polling','htmlfile','jsonp-polling']);
    io.set('authorization', function (data, cb) {
        authorizePHPSession(getPHPSessionId(data.headers.cookie), cb);
    });
});

        $result = $authDbTable->authenticate();
 
        if($result->isValid())
        {
            // lets store the user in the session
            $user = $authDbTable->getResultRowObject(array('id', 'role'), null);
            $usersTable->update(array('lastLogin'=>date('Y-m-d H:i:s')), array('id = ?'=>$user->id));
 
	    if($form->remember_me->checked) {
		Zend_Session::rememberMe();
	    } else {
		Zend_Session::forgetMe();
	    }
 
            // insert our session information.
            $user->nodeAuthorization = Zend_Session::getId();
 
            $auth = Zend_Auth::getInstance();
            $auth->getStorage()->write($user);
        }

/**
 * This function will look in the PHP Session directory and look for the session
 * file.  If the file exists it will load that file as a string and then parse
 * that string for the PHP Session which will only be stored once the PHP authorization
 * method saves it.  It also takes into consideration sessions that may not have been
 * gc'ed by PHP yet.
 */
var sessionExpiration = 86400;
function authorizePHPSession(data, cb) {
    var phpSessionId = getPHPSessionId(data.headers.cookie);
    fs.stat('/var/lib/php5/sess_'+phpSessionId, function(err, stats) {
        if(err) {
            cb(null, false);
        } else if(Date.now() - (Date.parse(stats.mtime)) > sessionExpiration) {
            cb(null, false);
        } else {
            try {
                fs.readFile('/var/lib/php5/sess_'+phpSessionId, 'utf8', function(err, fileContents) {
                    if(err) {
                        throw err;
                    } else if(fileContents.search(phpSessionId.toString()) > -1) {
                        data.phpSessionId = phpSessionId.toString();
                        cb(null, true);
                    } else {
                        cb(null, false);
                    }
                });
            } catch(e) {
                cb(null, false);
            }            
        }
    });
}

    /**
     * Sets validator options
     *
     * Accepts the following option keys:
     * - minheight
     * - minwidth
     * - maxheight
     * - maxwidth
     *
     * @param  Zend_Config|array $options
     * @return void
     */
    public function __construct($options)
    {
        if ($options instanceof Zend_Config) {
            $options = $options->toArray();
        } elseif (1 < func_num_args()) {
            if (!is_array($options)) {
                $options = array('minwidth' => $options);
            }
            $argv = func_get_args();
            array_shift($argv);
            $options['minheight'] = array_shift($argv);
            if (!empty($argv)) {
                $options['maxwidth'] = array_shift($argv);
                if (!empty($argv)) {
                    $options['maxheight'] = array_shift($argv);
                }
            }
        } else if (!is_array($options)) {
            require_once 'Zend/Validate/Exception.php';
            throw new Zend_Validate_Exception ('Invalid options to validator provided');
        }
 
        if (isset($options['minheight']) || isset($options['minwidth'])) {
            $this->setImageMin($options);
        }
 
        if (isset($options['maxheight']) || isset($options['maxwidth'])) {
            $this->setImageMax($options);
        }
    }

//backwards compatibility supports this but I find this to be something that should be broke as the constructors are now unified and this could be messy
$validatorA = new Zend_Validate_File_Image_Size(0,0,110,110);
// suggested way of passing in parameters to the constructor
$validatorB = new Zend_Validate_File_Image_Size(array('minheight'=>0, 'minwidth'=>0, 'maxheight'=>110, 'maxwidth'=>110));

  <security-constraint>
    <web-resource-collection>
      <web-resource-name>Solr authenticated application</web-resource-name>
      <url-pattern>/</url-pattern>
    </web-resource-collection>
    <auth-constraint>
      <role-name>administrator</role-name>
    </auth-constraint>
  </security-constraint>
 
  <login-config>
    <auth-method>BASIC</auth-method>
    <realm-name>My Solr</realm-name>
  </login-config>

    <Set name="UserRealms">
      <Array type="org.mortbay.jetty.security.UserRealm">
        <Item>
          <New class="org.mortbay.jetty.security.HashUserRealm">
            <Set name="name">My Solr</Set>
            <Set name="config"><SystemProperty name="jetty.home" default="."/>/etc/realm.properties</Set>
            <Set name="refreshInterval">0</Set>
          </New>
        </Item>
      </Array>
    </Set>

class Get2KnowMe_Search_FileGetContents extends Apache_Solr_HttpTransport_Abstract {
    private $authorization;
    private $username;
    private $password;
    private $_getContext;
    private $_postContext;
    private $_headContext;
 
    public function __construct($authorization = false, $username = null, $password = null) {
        $this->authorization = $authorization;
        $this->username = $username;
        $this->password = $password;
        $this->_getContext = stream_context_create();
        $this->_postContext = stream_context_create();
        $this->_headContext = stream_context_create();
    }
 
    public function performGetRequest($url, $timeout = false)
    {
        if($this->authorization) {
            stream_context_set_option($this->_getContext, 'http', 'header', 'Authorization: Basic ' . base64_encode($this->username.':'.$this->password));
        }
 
        // set the timeout if specified
        if ($timeout !== FALSE && $timeout > 0.0)
        {
                // timeouts with file_get_contents seem to need
                // to be halved to work as expected
                $timeout = (float) $timeout / 2;
 
                stream_context_set_option($this->_getContext, 'http', 'timeout', $timeout);
        }
        else
        {
                // use the default timeout pulled from default_socket_timeout otherwise
                stream_context_set_option($this->_getContext, 'http', 'timeout', $this->getDefaultTimeout());
        }
 
        // $http_response_headers will be updated by the call to file_get_contents later
        // see http://us.php.net/manual/en/wrappers.http.php for documentation
        // Unfortunately, it will still create a notice in analyzers if we don't set it here
        $http_response_header = null;
        $responseBody = @file_get_contents($url, false, $this->_getContext);
 
        return $this->_getResponseFromParts($responseBody, $http_response_header);
    }
 
    public function performHeadRequest($url, $timeout = false)
    {
        if($this->authorization) {
            stream_context_set_option($this->_headContext, 'http', 'header', 'Authorization: Basic ' . base64_encode($this->username.':'.$this->password));
        }
 
        stream_context_set_option($this->_headContext, array(
                        'http' => array(
                                // set HTTP method
                                'method' => 'HEAD',
 
                                // default timeout
                                'timeout' => $this->getDefaultTimeout()
                        )
                )
        );
 
        // set the timeout if specified
        if ($timeout !== FALSE && $timeout > 0.0)
        {
                // timeouts with file_get_contents seem to need
                // to be halved to work as expected
                $timeout = (float) $timeout / 2;
 
                stream_context_set_option($this->_headContext, 'http', 'timeout', $timeout);
        }
 
        // $http_response_headers will be updated by the call to file_get_contents later
        // see http://us.php.net/manual/en/wrappers.http.php for documentation
        // Unfortunately, it will still create a notice in analyzers if we don't set it here
        $http_response_header = null;
        $responseBody = @file_get_contents($url, false, $this->_headContext);
 
        return $this->_getResponseFromParts($responseBody, $http_response_header);
    }
 
    public function performPostRequest($url, $rawPost, $contentType, $timeout = false)
    {
        if($this->authorization) {
            stream_context_set_option($this->_postContext, 'http', 'header', 'Authorization: Basic ' . base64_encode($this->username.':'.$this->password) . "\r\n");
        }
 
        stream_context_set_option($this->_postContext, array(
                        'http' => array(
                                // set HTTP method
                                'method' => 'POST',
 
                                // Add our posted content type
                                'header' => "Content-Type: $contentType",
 
                                // the posted content
                                'content' => $rawPost,
 
                                // default timeout
                                'timeout' => $this->getDefaultTimeout()
                        )
                )
        );
 
        // set the timeout if specified
        if ($timeout !== FALSE && $timeout > 0.0)
        {
                // timeouts with file_get_contents seem to need
                // to be halved to work as expected
                $timeout = (float) $timeout / 2;
 
                stream_context_set_option($this->_postContext, 'http', 'timeout', $timeout);
        }
 
        // $http_response_header will be updated by the call to file_get_contents later
        // see http://us.php.net/manual/en/wrappers.http.php for documentation
        // Unfortunately, it will still create a notice in analyzers if we don't set it here
        $http_response_header = null;
        $responseBody = @file_get_contents($url, false, $this->_postContext);
 
        // reset content of post context to reclaim memory
        stream_context_set_option($this->_postContext, 'http', 'content', '');
 
        return $this->_getResponseFromParts($responseBody, $http_response_header);
    }
 
    private function _getResponseFromParts($rawResponse, $httpHeaders)
    {
            //Assume 0, false as defaults
            $status = 0;
            $contentType = false;
 
            //iterate through headers for real status, type, and encoding
            if (is_array($httpHeaders) && count($httpHeaders) > 0)
            {
                    //look at the first headers for the HTTP status code
                    //and message (errors are usually returned this way)
                    //
                    //HTTP 100 Continue response can also be returned before
                    //the REAL status header, so we need look until we find
                    //the last header starting with HTTP
                    //
                    //the spec: http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.1
                    //
                    //Thanks to Daniel Andersson for pointing out this oversight
                    while (isset($httpHeaders[0]) && substr($httpHeaders[0], 0, 4) == 'HTTP')
                    {
                            // we can do a intval on status line without the "HTTP/1.X " to get the code
                            $status = intval(substr($httpHeaders[0], 9));
 
                            // remove this from the headers so we can check for more
                            array_shift($httpHeaders);
                    }
 
                    //Look for the Content-Type response header and determine type
                    //and encoding from it (if possible - such as 'Content-Type: text/plain; charset=UTF-8')
                    foreach ($httpHeaders as $header)
                    {
                            // look for the header that starts appropriately
                            if (strncasecmp($header, 'Content-Type:', 13) == 0)
                            {
                                    $contentType = substr($header, 13);
                                    break;
                            }
                    }
            }
 
            return new Apache_Solr_HttpTransport_Response($status, $contentType, $rawResponse);
    }    
}