socket.php

一个基于web的rpg游戏源代码

function process_clients_commands(&$connections) {

    if (is_array($connections)) {
        foreach(array_keys($connections) as $key) {
            $socket = & $connections[$key]->socket;
            if(is_resource($socket) || get_resource_type($socket) != "Socket") {
                if (socket_ready($socket, "read")) {
                    $array_messages = process_client($connections[$key]);
                    if ($array_messages !== false) {
                        foreach ($array_messages as $mkey => $value) {
                            if ($connections[$key]->protocol_type == connection::P_AI) {
                                process_command_ai($connections[$key], $value);
                            } elseif ($connections[$key]->protocol_type == connection::P_FLASH) {
                                process_command($connections[$key], $value);
                            }
                        }
                    }
                }
            } else {
                throw new exception("bad socket in $index", debug_backtrace(),
                        get_socket_error($socket));
            }
        }
    }
    return(TRUE);
}

/**
* Process single client
*
* Called to process each client connection
*
* @param connection   object
*/
function process_client(&$connection)
{
    // filter args
    $message = array();
    if(is_a($connection, "connection") !== TRUE) {
        $m = "bad argument connection";
        throw new exception($m, debug_backtrace(), $connection);
        return(FALSE);
    }
    $input = read_data_from_socket($connection);
    
    if (strlen($input) < 1) {
        return(FALSE);
    }
   
    $pattern = "<?xml version=\"1.0\"?>";  
    $array_regs = explode($pattern, $input);
    if (empty($array_regs[0])) {
    	if (empty($connection->last_read)) {
            // Caso normal, hay que quitar el [0]
            unset ($array_regs[0]);
	    } else {
            // Hay un caso erroneo, pq ahora no hay ningun
            // trozo, pero del bloque de antes si, que se va 
            // a perder
            $msg = "no se que hacer con este trozo ";
            $msg.= $connection->last_read;
            log_msg($msg, "socket", $connection);
            $connection->last_read = '';
	    }
    } else {
    	// Ha leido el trozo que faltaba de la lectura de antes
        $array_regs[0] = $connection->last_read . $array_regs[0];
        $connection->last_read = '';
    }
    
    foreach ($array_regs as $xml_text) {
        if (!empty($xml_text)) {
            $parsed_xml = parse_input($xml_text);
            if (!$parsed_xml) {
	    	$connection->last_read = $xml_text;
                unset($array_regs);
                unset($input);
                return(FALSE);
            }
            $message[] = $xml_text;
        }
    }
    unset($array_regs);
    unset($input); 
    return($message);
}

/**
* Parses input from client
*
* Parse what to do from XML string
*
* @param input  string  string to filter
*/
function parse_input($input)
{
    // Detect XML by pieces
    if ((substr($input,0,1) != "<") || (substr($input,-1) != ">")) {
    	// this is a piece ... don't process
	    return(FALSE);
    }
   	return(TRUE);
}

/**
* Read buffer of client
*
* Read input buffer of socket and sent trhe data to parse
*
* @param connection   object
*/
function read_data_from_socket(&$connection)
{
    // filter args
    if(is_a($connection, "connection") !== TRUE) {
        $m = "bad argument connection";
        throw new exception($m, debug_backtrace(), $connection);
        return(FALSE);
    }

    // Coger datos mientras haya algo para leer, 
    // independientemente de la maxima lectura
    if (socket_ready ($connection->socket, "read")) {
        // read now, there are something to read, socket will not block
        $data = '';
        do { 
            $buf = socket_read($connection->socket, 2048);
            if (($buf === FALSE) || ($buf < 0) || (strlen($buf) < 1)){
		        close_socket($connection);
                return(FALSE);
            }
            $data .= $buf;
        } while(socket_ready($connection->socket, "read"));

        if (($data == '') && (socket_last_error($connection->socket) == 11)) {
            // nothing to read
            return(TRUE);
        }
    
        if ($data < 0 || strlen($data) < 1) {
            return(FALSE);
        }
         
        $data = trim($data);
        $data = str_replace("\0", "", $data);
        log_msg("<- ".$data, "socket", $connection);
        return($data);
    }
    return(TRUE);
}

/**
* Writes data to all client sockets
*
* Send some data to all clients sockets
*
* @param data      string  data to send to socket
* @param connection_list array   optional, limit to this list
*/
function write_data_to_all_sockets($data, &$connections, $connection_list=FALSE)
{
    // Filter arguments
    if (empty($data)) {
        $m = "bad argument data";
        throw new exception($m, debug_backtrace(), $data);
        return(FALSE);
    }
    
    // Use $clients_list if we need it to
    if(is_array($connection_list)) {
        $list_to_use = $connection_list;
    } else {
        $list_to_use = $connections;
    }

    // Go
    foreach(array_keys($list_to_use) as $key) {
        write_data_to_socket($list_to_use[$key], $data);
    }
    return(TRUE);
}

/**
* Writes data to socket
*
* Send some data to client
*
* @param connection object
* @param data       string data to send to socket
*/
function write_data_to_socket(&$connection, $data)
{
    global $conf;
   
    // Filter arguments
    if(is_a($connection, "connection") !== TRUE) {
        $m = "bad argument connection";
        throw new exception($m, debug_backtrace(), $connection);
        return(FALSE);
    }
    $socket = $connection->socket;
    if ((!is_resource($socket)) || (get_resource_type($socket) != "Socket")){
        throw new exception("Bad socket", debug_backtrace(), $socket);
        return(FALSE);
    }

    $protocol_type = $connection->protocol_type;
    
    //mirar si el socket esta preparat per escriure, 
    //sino montar una FIFO
    $is_ready_to_write = socket_ready($socket, "write");

    if (!$is_ready_to_write) {
        if (!empty($data)) {
            $len = strlen($connection->buffer);
            if($len > $conf['daemon']['max_length_buffer']) {
                $msg = "write_data_to_socket: buffer too large at";
                $msg.= $connection->remote_ip;
                log_msg($error_msg, "timeout", $connection);
                close_socket($connection);
                return(FALSE);
            } else {
                write_to_client_buffer($connection, $data);
            }
        }
        return(FALSE);
    }
    if(strlen($connection->buffer) > 0) {
        $len = strlen($connection->buffer);
        $msg = "write_data_to_socket: I'll empty cache of $len bytes for";
        $msg.= $connection->remote_ip;
    	log_msg($msg, "timeout", $connection);
    	$data = $connection->buffer . $data;
    	flush_buffer($connection);
    }
    log_msg ("-> ".$data, "socket", $connection);
    return (write_to_socket ($socket, $protocol_type, $data));
}

/**
* Writes data to socket, low level function
*
* @param socket         int     socket to write
* @param protocol_type  int     protocol used
* @param data           string  data to send to socket
*/
function write_to_socket ($socket, $protocol_type, $data)
{
    /*
      si data == "" despues de a馻dirle el buffer es que vamos mal
      mejor no enviar nada :)
    */

    if (empty($data)) {
        throw new exception("bad argument data", debug_backtrace(), $data);
        return(FALSE);
    }

    switch ($protocol_type) {
    case connection::P_AI:
        $data_str = sprintf("%s", $data);
        break;
    case connection::P_NONE:
    case connection::P_FLASH:
        $data_str = true_xml_to_flash($data); 
        break;
    }
    
    $n = socket_write($socket, $data_str);
    if ($n < 0) {
        $m = "could not write data to socket";
        throw new exception($m, debug_backtrace(), get_socket_error($n));
        close_socket($connection);
        return(FALSE);
    }
    return(TRUE);
}

/**
* Add data to client buffer
*/
function write_to_client_buffer(&$connection) 
{
	$connection->buffer.= $data;
    $msg = "write_to_client_buffer: could not write data to socket";
	log_msg($msg, "timeout", $connection);
	return(TRUE);
}

/**
* Empty client buffer
*/
function flush_buffer(&$connection) {
	$connection->buffer = '';
    $msg = "flush_buffer: erased buffer for socket";
   	log_msg($msg, "timeout", $connection);
	return(TRUE);
}

?>