eliseuamaro/gnu-social
1
0
Fork 0
forked from GNUsocial/gnu-social
Code Issues Pull Requests Releases Wiki Activity
Files
7c988b51ed310c70ba940804b22acd5a7e43b188
gnu-social/plugins/Aim/extlib/phptoclib/aimclassw.php
Craig Andrews e9995b0f6a Create IM plugin, Pluginize XMPP, Create AIM plugin
2010-01-27 13:48:35 -05:00

2371 lines
54 KiB
PHP
Executable File
Raw Blame History

<?php
/*
* PHPTOCLIB: A library for AIM connectivity through PHP using the TOC protocal.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
/**
* The version of PHPTOCLIB we are running right now
*
* @access private
* @var int
*/
define("PHPTOCLIB_VERSION","1.0.0 RC1");
// Prevents Script from Timing Out
//set_time_limit(0);
// Constant Declarations
/**
* Maximum size for a direct connection IM in bytes
*
* @access private
* @var int
*/
define("MAX_DIM_SIZE",3072); //Default to 3kb
/**
* Internally used for message type
*
* @access private
* @var int
*/
define("AIM_TYPE_WARN",74);
/**
* Internally used for message type
*
* @access private
* @var int
*/
define("AIM_TYPE_MSG",75);
/**
* Internally used for message type
*
* @access private
* @var int
*/
define("AIM_TYPE_UPDATEBUDDY",76);
/**
* Internally used for message type
*
* @access private
* @var int
*/
define("AIM_TYPE_SIGNON",77);
/**
* Internally used for message type
*
* @access private
* @var int
*/
define("AIM_TYPE_NICK",78);
/**
* Internally used for message type
*
* @access private
* @var int
*/
define("AIM_TYPE_ERROR",79);
/**
* Internally used for message type
*
* @access private
* @var int
*/
define("AIM_TYPE_CHATJ",80);
/**
* Internally used for message type
*
* @access private
* @var int
*/
define("AIM_TYPE_CHATI",81);
/**
* Internally used for message type
*
* @access private
* @var int
*/
define("AIM_TYPE_CHATUPDBUD",82);
/**
* Internally used for message type
*
* @access private
* @var int
*/
define("AIM_TYPE_CHATINV",83);
/**
* Internally used for message type
*
* @access private
* @var int
*/
define("AIM_TYPE_CHATLE",84);
/**
* Internally used for message type
*
* @access private
* @var int
*/
define("AIM_TYPE_URL",85);
/**
* Internally used for message type
*
* @access private
* @var int
*/
define("AIM_TYPE_NICKSTAT",86);
/**
* Internally used for message type
*
* @access private
* @var int
*/
define("AIM_TYPE_PASSSTAT",87);
/**
* Internally used for message type
*
* @access private
* @var int
*/
define("AIM_TYPE_RVOUSP",88);
/**
* Internally used for message type
*
* @access private
* @var int
*/
define("AIM_TYPE_NOT_IMPLEMENTED",666);
/**
* Internally used for connection type
*
* Internal type for a normal connection
*
* @access private
* @var int
*/
define("CONN_TYPE_NORMAL",1);
/**
* Internally used for connection type
*
* Internal type of a Dirct Connection
*
* @access private
* @var int
*/
define("CONN_TYPE_DC",2);
/**
* Internally used for connection type
*
*Internal type for a file transfer connection
*
* @access private
* @var int
*/
define("CONN_TYPE_FT",3);
/**
* Internally used for connection type
*
*Internal type for a file get connection
*
* @access private
* @var int
*/
define("CONN_TYPE_FTG",4);
/**
* Maximum size for a TOC packet
*
* @access private
* @var int
*/
define("MAX_PACKLENGTH",2048);
/**
* TOC packet type
*
* @access private
* @var int
*/
define("SFLAP_TYPE_SIGNON",1);
/**
* TOC packet type
*
* @access private
* @var int
*/
define("SFLAP_TYPE_DATA",2);
/**
* TOC packet type
*
* @access private
* @var int
*/
define("SFLAP_TYPE_ERROR",3);
/**
* TOC packet type
*
* @access private
* @var int
*/
define("SFLAP_TYPE_SIGNOFF",4);
/**
* TOC packet type
*
* @access private
* @var int
*/
define("SFLAP_TYPE_KEEPALIVE",5);
/**
* TOC packet type
*
* @access private
* @var int
*/
define("SFLAP_MAX_LENGTH",1024);
/**
* Service UID for a voice connection
*
* @access private
* @var int
*/
define('VOICE_UID', '09461341-4C7F-11D1-8222-444553540000');
/**
* Service UID for file sending
*
* @access private
* @var int
*/
define('FILE_SEND_UID', '09461343-4C7F-11D1-8222-444553540000');
/**
* Service UID for file getting
*
* @access private
* @var int
*/
define('FILE_GET_UID', '09461348-4C7F-11D1-8222-444553540000');
/**
* Service UID for Direct connections
*
* @access private
* @var int
*/
define('IMAGE_UID', '09461345-4C7F-11D1-8222-444553540000');
/**
* Service UID for Buddy Icons
*
* @access private
* @var int
*/
define('BUDDY_ICON_UID', '09461346-4C7F-11D1-8222-444553540000');
/**
* Service UID for stocks
*
* @access private
* @var int
*/
define('STOCKS_UID', '09461347-4C7F-11D1-8222-444553540000');
/**
* Service UID for games
*
* @access private
* @var int
*/
define('GAMES_UID', '0946134a-4C7F-11D1-8222-444553540000');
/**
* FLAP return code
*
* @access private
* @var int
*/
define("SFLAP_SUCCESS",0);
/**
* FLAP return code
*
* @access private
* @var int
*/
define("SFLAP_ERR_UNKNOWN",1);
/**
* FLAP return code
*
* @access private
* @var int
*/
define("SFLAP_ERR_ARGS",2);
/**
* FLAP return code
*
* @access private
* @var int
*/
define("SFLAP_ERR_LENGTH",3);
/**
* FLAP return code
*
* @access private
* @var int
*/
define("SFLAP_ERR_READ",4);
/**
* FLAP return code
*
* @access private
* @var int
*/
define("SFLAP_ERR_SEND",5);
/**
* FLAP version number
*
* @access private
* @var int
*/
define("SFLAP_FLAP_VERSION",1);
/**
* FLAP TLV code
*
* @access private
* @var int
*/
define("SFLAP_TLV_TAG",1);
/**
* Bytes in a FLAP header
*
* @access private
* @var int
*/
define("SFLAP_HEADER_LEN",6);
/**
* PHPTocLib AIM Class
*
* @author Jeremy Bryant <pickleman78@users.sourceforge.net>
* @author Rajiv Makhijani <rajiv@blue-tech.org>
* @package phptoclib
* @version 1.0RC1
* @copyright 2005
* @access public
*
*/
class Aim
{
/**
* AIM ScreenName
*
* @var String
* @access private
*/
var $myScreenName;
/**
* AIM Password (Plain Text)
*
* @var String
* @access private
*/
var $myPassword;
/**
* AIM TOC Server
*
* @var String
* @access public
*/
var $myServer="toc.oscar.aol.com";
/**
* AIM Formatted ScreenName
*
* @var String
* @access private
*/
var $myFormatSN;
/**
* AIM TOC Server Port
*
* @var String
* @access public
*/
var $myPort="5190";
/**
* Profile Data
* Use setProfile() to update
*
* @var String
* @access private
*/
var $myProfile="Powered by phpTOCLib. Please visit http://sourceforge.net/projects/phptoclib for more information"; //The profile of the bot
/**
* Socket Connection Resource ID
*
* @var Resource
* @access private
*/
var $myConnection; //Connection resource ID
/**
* Roasted AIM Password
*
* @var String
* @access private
*/
var $myRoastedPass;
/**
* Last Message Recieved From Server
*
* @var String
* @access private
*/
var $myLastReceived;
/**
* Current Seq Number Used to Communicate with Server
*
* @var Integer
* @access private
*/
var $mySeqNum;
/**
* Current Warning Level
* Getter: getWarning()
* Setter: setWarning()
*
* @var Integer
* @access private
*/
var $myWarnLevel; //Warning Level of the bot
/**
* Auth Code
*
* @var Integer
* @access private
*/
var $myAuthCode;
/**
* Buddies
* Getter: getBuddies()
*
* @var Array
* @access private
*/
var $myBuddyList;
/**
* Blocked Buddies
* Getter: getBlocked()
*
* @var Array
* @access private
*/
var $myBlockedList;
/**
* Permited Buddies
* Getter: getBlocked()
*
* @var Array
* @access private
*/
var $myPermitList;
/**
* Permit/Deny Mode
* 1 - Allow All
* 2 - Deny All
* 3 - Permit only those on your permit list
* 4 - Permit all those not on your deny list
*
* @var Integer
* @access private
*/
var $myPdMode;
//Below variables added 4-29 by Jeremy: Implementing chat
/**
* Contains Chat Room Info
* $myChatRooms['roomid'] = people in room
*
* @var Array
* @access private
*/
var $myChatRooms;
//End of chat implementation
/**
* Event Handler Functions
*
* @var Array
* @access private
*/
var $myEventHandlers = array();
/**
* Array of direct connection objects(including file transfers)
*
* @var Array
* @access private
*/
var $myDirectConnections = array();
/**
* Array of the actual connections
*
* @var Array
* @access private
*/
var $myConnections = array();
/**
* The current state of logging
*
* @var Boolean
* @access private
*/
var $myLogging = false;
/**
* Constructor
*
* Permit/Deny Mode Options
* 1 - Allow All
* 2 - Deny All
* 3 - Permit only those on your permit list
* 4 - Permit all those not on your deny list
*
* @param String $sn AIM Screenname
* @param String $password AIM Password
* @param Integer $pdmode Permit/Deny Mode
* @access public
*/
function Aim($sn, $password, $pdmode)
{
//Constructor assignment
$this->myScreenName = $this->normalize($sn);
$this->myPassword = $password;
$this->myRoastedPass = $this->roastPass($password);
$this->mySeqNum = 1;
$this->myConnection = 0;
$this->myWarnLevel = 0;
$this->myAuthCode = $this->makeCode();
$this->myPdMode = $pdmode;
$this->myFormatSN = $this->myScreenName;
$this->log("PHPTOCLIB v" . PHPTOCLIB_VERSION . " Object Created");
}
/**
* Enables debug logging (Logging is disabled by default)
*
*
* @access public
* @return void
*/
function setLogging($enable)
{
$this->myLogging=$enable;
}
function log($data)
{
if($this->myLogging){
error_log($data);
}
}
/**
* Logs a packet
*
*
* @access private
* @param Array $packary Packet
* @param String $in Prepend
* @return void
*/
function logPacket($packary,$in)
{
if(!$this->myLogging || sizeof($packary)<=0 || (@strlen($packary['decoded'])<=0 && @isset($packary['decoded'])))
return;
$towrite=$in . ": ";
foreach($packary as $k=>$d)
{
$towrite.=$k . ":" . $d . "\r\n";
}
$towrite.="\r\n\r\n";
$this->log($towrite);
}
/**
* Roasts/Hashes Password
*
* @param String $password Password
* @access private
* @return String Roasted Password
*/
function roastPass($password)
{
$roaststring = 'Tic/Toc';
$roasted_password = '0x';
for ($i = 0; $i < strlen($password); $i++)
$roasted_password .= bin2hex($password[$i] ^ $roaststring[($i % 7)]);
return $roasted_password;
}
/**
* Access Method for myScreenName
*
* @access public
* @param $formated Returns formatted Screenname if true as returned by server
* @return String Screenname
*/
function getMyScreenName($formated = false)
{
if ($formated)
{
return $this->myFormatSN;
}
else
{
return $this->normalize($this->myScreenName);
}
}
/**
* Generated Authorization Code
*
* @access private
* @return Integer Auth Code
*/
function makeCode()
{
$sn = ord($this->myScreenName[0]) - 96;
$pw = ord($this->myPassword[0]) - 96;
$a = $sn * 7696 + 738816;
$b = $sn * 746512;
$c = $pw * $a;
return $c - $a + $b + 71665152;
}
/**
* Reads from Socket
*
* @access private
* @return String Data
*/
function sflapRead()
{
if ($this->socketcheck($this->myConnection))
{
$this->log("Disconnected.... Reconnecting in 60 seconds");
sleep(60);
$this->signon();
}
$header = fread($this->myConnection,SFLAP_HEADER_LEN);
if (strlen($header) == 0)
{
$this->myLastReceived = "";
return "";
}
$header_data = unpack("aast/Ctype/nseq/ndlen", $header);
$this->log(" . ", false);
$packet = fread($this->myConnection, $header_data['dlen']);
if (strlen($packet) <= 0 && $sockinfo['blocked'])
$this->derror("Could not read data");
if ($header_data['type'] == SFLAP_TYPE_SIGNON)
{
$packet_data=unpack("Ndecoded", $packet);
}
if ($header_data['type'] == SFLAP_TYPE_KEEPALIVE)
{
$this->myLastReceived = '';
return 0;
}
else if (strlen($packet)>0)
{
$packet_data = unpack("a*decoded", $packet);
}
$this->log("socketcheck check now");
if ($this->socketcheck($this->myConnection))
{
$this->derror("Connection ended unexpectedly");
}
$data = array_merge($header_data, $packet_data);
$this->myLastReceived = $data;
$this->logPacket($data,"in");
return $data;
}
/**
* Sends Data on Socket
*
* @param String $sflap_type Type
* @param String $sflap_data Data
* @param boolean $no_null No Null
* @param boolean $formatted Format
* @access private
* @return String Roasted Password
*/
function sflapSend($sflap_type, $sflap_data, $no_null, $formatted)
{
$packet = "";
if (strlen($sflap_data) >= MAX_PACKLENGTH)
$sflap_data = substr($sflap_data,0,MAX_PACKLENGTH);
if ($formatted)
{
$len = strlen($sflap_len);
$sflap_header = pack("aCnn",'*', $sflap_type, $this->mySeqNum, $len);
$packet = $sflap_header . $sflap_data;
} else {
if (!$no_null)
{
$sflap_data = str_replace("\0","", trim($sflap_data));
$sflap_data .= "\0";
}
$data = pack("a*", $sflap_data);
$len = strlen($sflap_data);
$header = pack("aCnn","*", $sflap_type, $this->mySeqNum, $len);
$packet = $header . $data;
}
//Make sure we are still connected
if ($this->socketcheck($this->myConnection))
{
$this->log("Disconnected.... reconnecting in 60 seconds");
sleep(60);
$this->signon();
}
$sent = fputs($this->myConnection, $packet) or $this->derror("Error sending packet to AIM");
$this->mySeqNum++;
sleep(ceil($this->myWarnLevel/10));
$this->logPacket(array($sflap_type,$sflap_data),"out");
}
/**
* Escape the thing that TOC doesn't like,that would be
* ",', $,{,},[,]
*
* @param String $data Data to Escape
* @see decodeData
* @access private
* @return String $data Escaped Data
*/
function encodeData($data)
{
$data = str_replace('"','\"', $data);
$data = str_replace('$','\$', $data);
$data = str_replace("'","\'", $data);
$data = str_replace('{','\{', $data);
$data = str_replace('}','\}', $data);
$data = str_replace('[','\[', $data);
$data = str_replace(']','\]', $data);
return $data;
}
/**
* Unescape data TOC has escaped
* ",', $,{,},[,]
*
* @param String $data Data to Unescape
* @see encodeData
* @access private
* @return String $data Unescape Data
*/
function decodeData($data)
{
$data = str_replace('\"','"', $data);
$data = str_replace('\$','$', $data);
$data = str_replace("\'","'", $data);
$data = str_replace('\{','{', $data);
$data = str_replace('\}','}', $data);
$data = str_replace('\[','[', $data);
$data = str_replace('\]',']', $data);
$data = str_replace('&quot;','"', $data);
$data = str_replace('&amp;','&', $data);
return $data;
}
/**
* Normalize ScreenName
* no spaces and all lowercase
*
* @param String $nick ScreenName
* @access public
* @return String $nick Normalized ScreenName
*/
function normalize($nick)
{
$nick = str_replace(" ","", $nick);
$nick = strtolower($nick);
return $nick;
}
/**
* Sets internal info with update buddy
* Currently only sets warning level
*
* @access public
* @return void
*/
function setMyInfo()
{
//Sets internal values bvase on the update buddy command
$this->log("Setting my warning level ...");
$this->sflapSend(SFLAP_TYPE_DATA,"toc_get_status " . $this->normalize($this->myScreenName),0,0);
//The rest of this will now be handled by the other functions. It is assumed
//that we may have other data queued in the socket, do we should just add this
//message to the queue instead of trying to set it in here
}
/**
* Connects to AIM and Signs On Using Info Provided in Constructor
*
* @access public
* @return void
*/
function signon()
{
$this->log("Ready to sign on to the server");
$this->myConnection = fsockopen($this->myServer, $this->myPort, $errno, $errstr,10) or die("$errorno:$errstr");
$this->log("Connected to server");
$this->mySeqNum = (time() % 65536); //Select an arbitrary starting point for
//sequence numbers
if (!$this->myConnection)
$this->derror("Error connecting to toc.oscar.aol.com");
$this->log("Connected to AOL");
//Send the flapon packet
fputs($this->myConnection,"FLAPON\r\n\n\0"); //send the initial handshake
$this->log("Sent flapon");
$this->sflapRead(); //Make sure the server responds with what we expect
if (!$this->myLastReceived)
$this->derror("Error sending the initialization string");
//send the FLAP SIGNON packet back with what it needs
//There are 2 parts to the signon packet. They are sent in succession, there
//is no indication if either packet was correctly sent
$signon_packet = pack("Nnna".strlen($this->myScreenName),1,1,strlen($this->myScreenName), $this->myScreenName);
$this->sflapSend(SFLAP_TYPE_SIGNON, $signon_packet,1,0);
$this->log("sent signon packet part one");
$signon_packet_part2 = 'toc2_signon login.oscar.aol.com 29999 ' . $this->myScreenName . ' ' . $this->myRoastedPass . ' english-US "TIC:TOC2:REVISION" 160 ' . $this->myAuthCode;
$this->log($signon_packet_part2 . "");
$this->sflapSend(SFLAP_TYPE_DATA, $signon_packet_part2,0,0);
$this->log("Sent signon packet part 2... Awaiting response...");
$this->sflapRead();
$this->log("Received Sign on packet, beginning initilization...");
$message = $this->getLastReceived();
$this->log($message . "\n");
if (strstr($message,"ERROR:"))
{
$this->onError($message);
die("Fatal signon error");
}
stream_set_timeout($this->myConnection,2);
//The information sent before the config2 command is utterly useless to us
//So we will just skim through them until we reach it
//Add the first entry to the connection array
$this->myConnections[] = $this->myConnection;
//UPDATED 4/12/03: Now this will use the receive function and send the
//received messaged to the assigned handlers. This is where the signon
//method has no more use
$this->log("Done with signon proccess");
//socket_set_blocking($this->myConnection,false);
}
/**
* Sends Instant Message
*
* @param String $to Message Recipient SN
* @param String $message Message to Send
* @param boolean $auto Sent as Auto Response / Away Message Style
* @access public
* @return void
*/
function sendIM($to, $message, $auto = false)
{
if ($auto) $auto = "auto";
else $auto = "";
$to = $this->normalize($to);
$message = $this->encodeData($message);
$command = 'toc2_send_im "' . $to . '" "' . $message . '" ' . $auto;
$this->sflapSend(SFLAP_TYPE_DATA, trim($command),0,0);
$cleanedmessage = str_replace("<br>", " ", $this->decodeData($message));
$cleanedmessage = strip_tags($cleanedmessage);
$this->log("TO - " . $to . " : " . $cleanedmessage);
}
/**
* Set Away Message
*
* @param String $message Away message (some HTML supported).
* Use null to remove the away message
* @access public
* @return void
*/
function setAway($message)
{
$message = $this->encodeData($message);
$command = 'toc_set_away "' . $message . '"';
$this->sflapSend(SFLAP_TYPE_DATA, trim($command),0,0);
$this->log("SET AWAY MESSAGE - " . $this->decodeData($message));
}
/**
* Fills Buddy List
* Not implemented fully yet
*
* @access public
* @return void
*/
function setBuddyList()
{
//This better be the right message
$message = $this->myLastReceived['decoded'];
if (strpos($message,"CONFIG2:") === false)
{
$this->log("setBuddyList cannot be called at this time because I got $message");
return false;
}
$people = explode("\n",trim($message,"\n"));
//The first 3 elements of the array are who knows what, element 3 should be
//a letter followed by a person
for($i = 1; $i<sizeof($people); $i++)
{
@list($mode, $name) = explode(":", $people[$i]);
switch($mode)
{
case 'p':
$this->myPermitList[] = $name;
break;
case 'd':
$this->myBlockedList[] = $name;
break;
case 'b':
$this->myBuddyList[] = $name;
break;
case 'done':
break;
default:
//
}
}
}
/**
* Adds buddy to Permit list
*
* @param String $buddy Buddy's Screenname
* @access public
* @return void
*/
function addPermit($buddy)
{
$this->sflapSend(SFLAP_TYPE_DATA,"toc2_add_permit " . $this->normalize($buddy),0,0);
$this->myPermitList[] = $this->normalize($buddy);
return 1;
}
/**
* Blocks buddy
*
* @param String $buddy Buddy's Screenname
* @access public
* @return void
*/
function blockBuddy($buddy)
{
$this->sflapSend(SFLAP_TYPE_DATA,"toc2_add_deny " . $this->normalize($buddy),0,0);
$this->myBlockedList[] = $this->normalize($buddy);
return 1;
}
/**
* Returns last message received from server
*
* @access private
* @return String Last Message from Server
*/
function getLastReceived()
{
if (@$instuff = $this->myLastReceived['decoded']){
return $this->myLastReceived['decoded'];
}else{
return;
}
}
/**
* Returns Buddy List
*
* @access public
* @return array Buddy List
*/
function getBuddies()
{
return $this->myBuddyList;
}
/**
* Returns Permit List
*
* @access public
* @return array Permit List
*/
function getPermit()
{
return $this->myPermitList;
}
/**
* Returns Blocked Buddies
*
* @access public
* @return array Blocked List
*/
function getBlocked()
{
return $this->myBlockedList;
}
/**
* Reads and returns data from server
*
* This is a wrapper for $Aim->sflap_read(), and only returns the $this->myLastReceived['data']
* portion of the message. It is preferred that you do not call $Aim->sflap_read() and use this
* function instead. This function has a return value. Calling this prevents the need to call
* $Aim->getLastReceived()
*
* @access public
* @return String Data recieved from server
*/
function read_from_aim()
{
$this->sflapRead();
$returnme = $this->getLastReceived();
return $returnme;
}
/**
* Sets current internal warning level
*
* This allows you to update the bots warning level when warned.
*
* @param int Warning Level %
* @access private
* @return void
*/
function setWarningLevel($warnlevel)
{
$this->myWarnLevel = $warnlevel;
}
/**
* Warns / "Evils" a User
*
* To successfully warn another user they must have sent you a message.
* There is a limit on how much and how often you can warn another user.
* Normally when you warn another user they are aware who warned them,
* however there is the option to warn anonymously. When warning anon.
* note that the warning is less severe.
*
* @param String $to Screenname to warn
* @param boolean $anon Warn's anonymously if true. (default = false)
* @access public
* @return void
*/
function warnUser($to, $anon = false)
{
if (!$anon)
$anon = '"norm"';
else
$anon = '"anon"';
$this->sflapSend(SFLAP_TYPE_DATA,"toc_evil " . $this->normalize($to) . " $anon",0,0);
}
/**
* Returns warning level of bot
*
* @access public
* @return void
*/
function getWarningLevel()
{
return $this->myWarningLevel;
}
/**
* Sets bot's profile/info
*
* Limited to 1024 bytes.
*
* @param String $profiledata Profile Data (Can contain limited html: br,hr,font,b,i,u etc)
* @param boolean $poweredby If true, appends link to phpTOCLib project to profile
* @access public
* @return void
*/
function setProfile($profiledata, $poweredby = false)
{
if ($poweredby == false){
$this->myProfile = $profiledata;
}else{
$this->myProfile = $profiledata . "<font size=1 face=tahoma><br><br>Powered by phpTOCLib<br>http://sourceforge.net/projects/phptoclib</font>";
}
$this->sflapSend(SFLAP_TYPE_DATA,"toc_set_info \"" . $this->encodeData($this->myProfile) . "\"",0,0);
$this->setMyInfo();
$this->log("Profile has been updated...");
}
//6/29/04 by Jeremy:
//Added mthod to accept a rvous,decline it, and
//read from the rvous socket
//Decline
/**
* Declines a direct connection request (rvous)
*
* @param String $nick ScreenName request was from
* @param String $cookie Request cookie (from server)
* @param String $uuid UUID
*
* @access public
* @return void
*/
function declineRvous($nick, $cookie, $uuid)
{
$nick = $this->normalize($nick);
$this->sflapSend(SFLAP_TYPE_DATA,"toc_rvous_cancel $nick $cookie $uuid",0,0);
}
/**
* Accepts a direct connection request (rvous)
*
* @param String $nick ScreenName request was from
* @param String $cookie Request cookie (from server)
* @param String $uuid UUID
* @param String $vip IP of User DC with
* @param int $port Port number to connect to
*
* @access public
* @return void
*/
function acceptRvous($nick, $cookie, $uuid, $vip, $port)
{
$this->sflapSend(SFLAP_TYPE_DATA,"toc_rvous_accept $nick $cookie $uuid",0,0);
//Now open the connection to that user
if ($uuid == IMAGE_UID)
{
$dcon = new Dconnect($vip, $port);
}
else if ($uuid == FILE_SEND_UID)
{
$dcon = new FileSendConnect($vip, $port);
}
if (!$dcon->connected)
{
$this->log("The connection failed");
return false;
}
//Place this dcon object inside the array
$this->myDirectConnections[] = $dcon;
//Place the socket in an array to
$this->myConnections[] = $dcon->sock;
//Get rid of the first packet because its worthless
//and confusing
$dcon->readDIM();
//Assign the cookie
$dcon->cookie = $dcon->lastReceived['cookie'];
$dcon->connectedTo = $this->normalize($nick);
return $dcon;
}
/**
* Sends a Message over a Direct Connection
*
* Only works if a direct connection is already established with user
*
* @param String $to Message Recipient SN
* @param String $message Message to Send
*
* @access public
* @return void
*/
function sendDim($to, $message)
{
//Find the connection
for($i = 0;$i<sizeof($this->myDirectConnections);$i++)
{
if ($this->normalize($to) == $this->myDirectConnections[$i]->connectedTo && $this->myDirectConnections[$i]->type == CONN_TYPE_DC)
{
$dcon = $this->myDirectConnections[$i];
break;
}
}
if (!$dcon)
{
$this->log("Could not find a direct connection to $to");
return false;
}
$dcon->sendMessage($message, $this->normalize($this->myScreenName));
return true;
}
/**
* Closes an established Direct Connection
*
* @param DConnect $dcon Direct Connection Object to Close
*
* @access public
* @return void
*/
function closeDcon($dcon)
{
$nary = array();
for($i = 0;$i<sizeof($this->myConnections);$i++)
{
if ($dcon->sock == $this->myConnections[$i])
unset($this->myConnections[$i]);
}
$this->myConnections = array_values($this->myConnections);
unset($nary);
$nary2 = array();
for($i = 0;$i<sizeof($this->myDirectConnections);$i++)
{
if ($dcon == $this->myDirectConnections[$i])
unset($this->myDirectConnections[$i]);
}
$this->myDirectConnections = array_values($this->myDirectConnections);
$dcon->close();
unset($dcon);
}
//Added 4/29/04 by Jeremy:
//Various chat related methods
/**
* Accepts a Chat Room Invitation (Joins room)
*
* @param String $chatid ID of Chat Room
*
* @access public
* @return void
*/
function joinChat($chatid)
{
$this->sflapSend(SFLAP_TYPE_DATA,"toc_chat_accept " . $chatid,0,0);
}
/**
* Leaves a chat room
*
* @param String $chatid ID of Chat Room
*
* @access public
* @return void
*/
function leaveChat($chatid)
{
$this->sflapSend(SFLAP_TYPE_DATA,"toc_chat_leave " . $chatid,0,0);
}
/**
* Sends a message in a chat room
*
* @param String $chatid ID of Chat Room
* @param String $message Message to send
*
* @access public
* @return void
*/
function chatSay($chatid, $message)
{
$this->sflapSend(SFLAP_TYPE_DATA,"toc_chat_send " . $chatid . " \"" . $this->encodeData($message) . "\"",0,0);
}
/**
* Invites a user to a chat room
*
* @param String $chatid ID of Chat Room
* @param String $who Screenname of user
* @param String $message Note to include with invitiation
*
* @access public
* @return void
*/
function chatInvite($chatid, $who, $message)
{
$who = $this->normalize($who);
$this->sflapSend(SFLAP_TYPE_DATA,"toc_chat_invite " . $chatid . " \"" . $this->encodeData($message) . "\" " . $who,0,0);
}
/**
* Joins/Creates a new chat room
*
* @param String $name Name of the new chat room
* @param String $exchange Exchange of new chat room
*
* @access public
* @return void
*/
function joinNewChat($name, $exchange)
{
//Creates a new chat
$this->sflapSend(SFLAP_TYPE_DATA,"toc_chat_join " . $exchange . " \"" . $name . "\"",0,0);
}
/**
* Disconnect error handler, attempts to reconnect in 60 seconds
*
* @param String $message Error message (desc of where error encountered etc)
*
* @access private
* @return void
*/
function derror($message)
{
$this->log($message);
$this->log("Error");
fclose($this->myConnection);
if ((time() - $GLOBALS['errortime']) < 600){
$this->log("Reconnecting in 60 Seconds");
sleep(60);
}
$this->signon();
$GLOBALS['errortime'] = time();
}
/**
* Returns connection type of socket (main or rvous etc)
*
* Helper method for recieve()
*
* @param Resource $sock Socket to determine type for
*
* @access private
* @return void
* @see receive
*/
function connectionType($sock)
{
//Is it the main connection?
if ($sock == $this->myConnection)
return CONN_TYPE_NORMAL;
else
{
for($i = 0;$i<sizeof($this->myDirectConnections);$i++)
{
if ($sock == $this->myDirectConnections[$i]->sock)
return $this->myDirectConnections[$i]->type;
}
}
return false;
}
/**
* Checks for new data and calls appropriate methods
*
* This method is usually called in an infinite loop to keep checking for new data
*
* @access public
* @return void
* @see connectionType
*/
function receive()
{
//This function will be used to get the incoming data
//and it will be used to call the event handlers
//First, get an array of sockets that have data that is ready to be read
$ready = array();
$ready = $this->myConnections;
$numrdy = stream_select($ready, $w = NULL, $x = NULL,NULL);
//Now that we've waited for something, go through the $ready
//array and read appropriately
for($i = 0;$i<sizeof($ready);$i++)
{
//Get the type
$type = $this->connectionType($ready[$i]);
if ($type == CONN_TYPE_NORMAL)
{
//Next step:Get the data sitting in the socket
$message = $this->read_from_aim();
if (strlen($message) <= 0)
{
return;
}
//Third step: Get the command from the server
@list($cmd, $rest) = explode(":", $message);
//Fourth step, take the command, test the type, and pass it off
//to the correct internal handler. The internal handler will
//do what needs to be done on the class internals to allow
//it to work, then proceed to pass it off to the user created handle
//if there is one
$this->log($cmd);
switch($cmd)
{
case 'SIGN_ON':
$this->onSignOn($message);
break;
case 'CONFIG2':
$this->onConfig($message);
break;
case 'ERROR':
$this->onError($message);
break;
case 'NICK':
$this->onNick($message);
break;
case 'IM_IN2':
$this->onImIn($message);
break;
case 'UPDATE_BUDDY2':
$this->onUpdateBuddy($message);
break;
case 'EVILED':
$this->onWarn($message);
break;
case 'CHAT_JOIN':
$this->onChatJoin($message);
break;
case 'CHAT_IN':
$this->onChatIn($message);
break;
case 'CHAT_UPDATE_BUDDY':
$this->onChatUpdate($message);
break;
case 'CHAT_INVITE':
$this->onChatInvite($message);
break;
case 'CHAT_LEFT':
$this->onChatLeft($message);
break;
case 'GOTO_URL':
$this->onGotoURL($message);
break;
case 'DIR_STATUS':
$this->onDirStatus($message);
break;
case 'ADMIN_NICK_STATUS':
$this->onAdminNick($message);
break;
case 'ADMIN_PASSWD_STATUS':
$this->onAdminPasswd($message);
break;
case 'PAUSE':
$this->onPause($message);
break;
case 'RVOUS_PROPOSE':
$this->onRvous($message);
break;
default:
$this->log("Fell through: $message");
$this->CatchAll($message);
break;
}
}
else
{
for($j = 0;$j<sizeof($this->myDirectConnections);$j++)
{
if ($this->myDirectConnections[$j]->sock == $ready[$i])
{
$dcon = $this->myDirectConnections[$j];
break;
}
}
//Now read from the dcon
if ($dcon->type == CONN_TYPE_DC)
{
if ($dcon->readDIM() == false)
{
$this->closeDcon($dcon);
continue;
}
$message['message'] = $dcon->lastMessage;
if ($message['message'] == "too big")
{
$this->sendDim("Connection dropped because you sent a message larger that " . MAX_DCON_SIZE . " bytes.", $dcon->connectedTo);
$this->closeDcon($dcon);
continue;
}
$message['from'] = $dcon->connectedTo;
$this->onDimIn($message);
}
}
}
$this->conn->myLastReceived="";
//Now get out of this function because the handlers should take care
//of everything
}
//The next block of code is all the event handlers needed by the class
//Some are left blank and only call the users handler because the class
//either does not support the command, or cannot do anything with it
// ---------------------------------------------------------------------
/**
* Direct IM In Event Handler
*
* Called when Direct IM is received.
* Call's user handler (if available) for DimIn.
*
* @access private
* @param String $data Raw message from server
* @return void
*/
function onDimIn($data)
{
$this->callHandler("DimIn", $data);
}
/**
* Sign On Event Handler
*
* Called when Sign On event occurs.
* Call's user handler (if available) for SIGN_ON.
*
* @access private
* @param String $data Raw message from server
* @return void
*/
function onSignOn($data)
{
$this->callHandler("SignOn", $data);
}
/**
* Config Event Handler
*
* Called when Config data received.
* Call's user handler (if available) for Config.
*
* Loads buddy list and other info
*
* @access private
* @param String $data Raw message from server
* @return void
*/
function onConfig($data)
{
$this->log("onConfig Message: " . $data);
if (strpos($data,"CONFIG2:") === false)
{
$this->log("get_buddy_list cannot be called at this time because I got $data");
//return false;
}
$people = explode("\n",trim($data,"\n"));
//The first 3 elements of the array are who knows what, element 3 should be
//a letter followed by a person
//AIM decided to add this wonderful new feature, the recent buddy thing, this kind of
//messes this funtion up, so we need to adapt it... unfortuneately, its not really
//clear how this works, so we are just going to add their name to the permit list.
//Recent buddies I believe are in the format
//number:name:number.... I think the first number counts down from 25 how long its
//been... but I don't know the second number,,,,
//TODO: Figure out the new recent buddies system
//Note: adding that at the bottom is a quick hack and may have adverse consequences...
for($i = 1;$i<sizeof($people);$i++)
{
@list($mode, $name) = explode(":", $people[$i]);
switch($mode)
{
case 'p':
$this->myPermitList[] = $name;
break;
case 'd':
$this->myBlockedList[] = $name;
break;
case 'b':
$this->myBuddyList[] = $name;
break;
case 'done':
break;
default:
//This is assumed to be recent buddies...
$this->myPermitList[]=$name;
}
}
//We only get the config message once, so now we should send our pd mode
$this->sflapSend(SFLAP_TYPE_DATA,"toc2_set_pdmode " . $this->myPdMode,0,0);
//Adds yourself to the permit list
//This is to fix an odd behavior if you have nobody on your list
//the server won't send the config command... so this takes care of it
$this->sflapSend(SFLAP_TYPE_DATA,"toc2_add_permit " . $this->normalize($this->myScreenName),0,0);
//Now we allow the user to send a list, update anything they want, etc
$this->callHandler("Config", $data);
//Now that we have taken care of what the user wants, send the init_done message
$this->sflapSend(SFLAP_TYPE_DATA,"toc_init_done",0,0);
//'VOICE_UID'
//'FILE_GET_UID'
//'IMAGE_UID'
//'BUDDY_ICON_UID'
//'STOCKS_UID'
//'GAMES_UID'
$this->sflapSend(SFLAP_TYPE_DATA, "toc_set_caps " . IMAGE_UID . " " . FILE_SEND_UID ." " . FILE_GET_UID . " " . BUDDY_ICON_UID . "",0,0);
}
/**
* Error Event Handler
*
* Called when an Error occurs.
* Call's user handler (if available) for Error.
*
* @access private
* @param String $data Raw message from server
* @return void
*/
function onError($data)
{
static $errarg = '';
static $ERRORS = array(
0=>'Success',
901 =>'$errarg not currently available',
902 =>'Warning of $errarg not currently available',
903 =>'A message has been dropped, you are exceeding
the server speed limit',
911 =>'Error validating input',
912 =>'Invalid account',
913 =>'Error encountered while processing request',
914 =>'Service unavailable',
950 =>'Chat in $errarg is unavailable.',
960 =>'You are sending message too fast to $errarg',
961 =>'You missed an im from $errarg because it was too big.',
962 =>'You missed an im from $errarg because it was sent too fast.',
970 =>'Failure',
971 =>'Too many matches',
972 =>'Need more qualifiers',
973 =>'Dir service temporarily unavailable',
974 =>'Email lookup restricted',
975 =>'Keyword Ignored',
976 =>'No Keywords',
977 =>'Language not supported',
978 =>'Country not supported',
979 =>'Failure unknown $errarg',
980 =>'Incorrect nickname or password.',
981 =>'The service is temporarily unavailable.',
982 =>'Your warning level is currently too high to sign on.',
983 =>'You have been connecting and
disconnecting too frequently. Wait 10 minutes and try again.
If you continue to try, you will need to wait even longer.',
989 =>'An unknown signon error has occurred $errarg'
);
$data_array = explode(":", $data);
for($i=0; $i<count($data_array); $i++)
{
switch($i)
{
case 0:
$cmd = $data_array[$i];
break;
case 1:
$errornum = $data_array[$i];
break;
case 2:
$errargs = $data_array[$i];
break;
}
}
eval("\$errorstring=\"\$ERRORS[" . $errornum . "]\";");
$string = "\$errorstring=\"\$ERRORS[$errornum]\";";
//This is important information! We need
// a A different outputter for errors
// b Just to echo it
//I'm just going to do a straight echo here, becuse we assume that
//the user will NEED to see this error. An option to supress it will
//come later I think. Perhaps if we did an error reporting level, similar
//to PHP's, and we could probably even use PHP's error outputting system
//I think that may be an idea....
$this->log($errorstring . "\n");
$this->callHandler("Error", $data);
}
/**
* Nick Event Handler
*
* Called when formatted own ScreenName is receieved
* Call's user handler (if available) for Nick.
*
* @access private
* @param String $data Raw message from server
* @return void
*/
function onNick($data)
{
//This is our nick, so set a field called "myFormatSN" which will represent
//the actual name given by the server to us, NOT the normalized screen name
@list($cmd, $nick) = explode(":", $data);
$this->myFormatSN = $nick;
$this->callHandler("Nick", $data);
}
/**
* IM In Event Handler
*
* Called when an Instant Message is received.
* Call's user handler (if available) for IMIn.
*
* @access private
* @param String $data Raw message from server
* @return void
*/
function onImIn($data)
{
//Perhaps we should add an internal log for debugging purposes??
//But now, this should probably be handled by the user purely
$this->callHandler("IMIn", $data);
}
/**
* UpdateBuddy Event Handler
*
* Called when a Buddy Update is receieved.
* Call's user handler (if available) for UpdateBuddy.
* If info is about self, updates self info (Currently ownly warning).
*
* ToDo: Keep track of idle, warning etc on Buddy List
*
* @access private
* @param String $data Raw message from server
* @return void
*/
function onUpdateBuddy($data)
{
//Again, since our class currently does not deal with other people without
//outside help, then this is also probably best left to the user. Though
//we should probably allow this to replace the setMyInfo function above
//by handling the input if and only if it is us
//Check and see that this is the command expected
if (strpos($data,"UPDATE_BUDDY2:") == -1)
{
$this->log("A different message than expected was received");
return false;
}
//@list($cmd, $info['sn'], $info['online'], $info['warnlevel'], $info['signon'], $info['idle'], $info['uc']) = explode(":", $command['incoming']);
//@list($cmd, $sn, $online, $warning, $starttime, $idletime, $uc) = explode(":", $data);
$info = $this->getMessageInfo($data);
if ($this->normalize($info['sn']) == $this->normalize($this->myScreenName))
{
$warning = rtrim($info['warnlevel'],"%");
$this->myWarnLevel = $warning;
$this->log("My warning level is $this->myWarnLevel %");
}
$this->callHandler("UpdateBuddy", $data);
}
/**
* Warning Event Handler
*
* Called when bot is warned.
* Call's user handler (if available) for Warn.
* Updates internal warning level
*
* @access private
* @param String $data Raw message from server
* @return void
*/
function onWarn($data)
{
/*
For reference:
$command['incoming'] .= ":0";
$it = explode(":", $command['incoming']);
$info['warnlevel'] = $it[1];
$info['from'] = $it[2];
*/
//SImply update our warning level
//@list($cmd, $newwarn, $user) = explode(":", $data);
$info = $this->getMessageInfo($data);
$this->setWarningLevel(trim($info['warnlevel'],"%"));
$this->log("My warning level is $this->myWarnLevel %");
$this->callHandler("Warned", $data);
}
/**
* Chat Join Handler
*
* Called when bot joins a chat room.
* Call's user handler (if available) for ChatJoin.
* Adds chat room to internal chat room list.
*
* @access private
* @param String $data Raw message from server
* @return void
*/
function onChatJoin($data)
{
@list($cmd, $rmid, $rmname) = explode(":", $data);
$this->myChatRooms[$rmid] = 0;
$this->callHandler("ChatJoin", $data);
}
/**
* Returns number of chat rooms bot is in
*
* @access public
* @param String $data Raw message from server
* @return int
*/
function getNumChats()
{
return count($this->myChatRooms);
}
/**
* Chat Update Handler
*
* Called when bot received chat room data (user update).
* Call's user handler (if available) for ChatUpdate.
*
* @access private
* @param String $data Raw message from server
* @return void
*/
function onChatUpdate($data)
{
$stuff = explode(":", $data);
$people = sizeof($stuff);
$people -= 2;
$this->callHandler("ChatUpdate", $data);
}
/**
* Chat Message In Handler
*
* Called when chat room message is received.
* Call's user handler (if available) for ChatIn.
*
* @access private
* @param String $data Raw message from server
* @return void
*/
function onChatIn($data)
{
$this->callHandler("ChatIn", $data);
}
/**
* Chat Invite Handler
*
* Called when bot is invited to a chat room.
* Call's user handler (if available) for ChatInvite.
*
* @access private
* @param String $data Raw message from server
* @return void
*/
function onChatInvite($data)
{
//@list($cmd, $name, $id, $from, $data) = explode(":", $data,6);
//$data = explode(":",$data,6);
//$nm = array();
//@list($nm['cmd'],$nm['name'],$nm['id'],$nm['from'],$nm['message']) = $data;
$this->callHandler("ChatInvite", $data);
}
/**
* Chat Left Handler
*
* Called when bot leaves a chat room
* Call's user handler (if available) for ChatLeft.
*
* @access private
* @param String $data Raw message from server
* @return void
*/
function onChatLeft($data)
{
$info = $this->getMessageInfo($data);
unset($this->myChatRooms[$info['chatid']]);
$this->callHandler("ChatLeft", $data);
}
/**
* Goto URL Handler
*
* Called on GotoURL.
* Call's user handler (if available) for GotoURL.
* No detailed info available for this / Unsupported.
*
* @access private
* @param String $data Raw message from server
* @return void
*/
function onGotoURL($data)
{
//This is of no use to the internal class
$this->callHandler("GotoURL", $data);
}
/**
* Dir Status Handler
*
* Called on DirStatus.
* Call's user handler (if available) for DirStatus.
* No detailed info available for this / Unsupported.
*
* @access private
* @param String $data Raw message from server
* @return void
*/
function onDirStatus($data)
{
//This is not currently suported
$this->callHandler("DirStatus", $data);
}
/**
* AdminNick Handler
*
* Called on AdminNick.
* Call's user handler (if available) for AdminNick.
* No detailed info available for this / Unsupported.
*
* @access private
* @param String $data Raw message from server
* @return void
*/
function onAdminNick($data)
{
//NOt particularly useful to us
$this->callHandler("AdminNick", $data);
}
/**
* AdminPasswd Handler
*
* Called on AdminPasswd.
* Call's user handler (if available) for AdminPasswd.
* No detailed info available for this / Unsupported.
*
* @access private
* @param String $data Raw message from server
* @return void
*/
function onAdminPasswd($data)
{
//Also not particlualry useful to the internals
$this->callHandler("AdminPasswd", $data);
}
/**
* Pause Handler
*
* Called on Pause.
* Call's user handler (if available) for Pause.
* No detailed info available for this / Unsupported.
*
* @access private
* @param String $data Raw message from server
* @return void
*/
function onPause($data)
{
//This is pretty useless to us too...
$this->callHandler("Pause", $data);
}
/**
* Direct Connection Handler
*
* Called on Direct Connection Request(Rvous).
* Call's user handler (if available) for Rvous.
*
* @access private
* @param String $data Raw message from server
* @return void
*/
function onRvous($data)
{
$this->callHandler("Rvous", $data);
}
/**
* CatchAll Handler
*
* Called for unrecognized commands.
* Logs unsupported messages to array.
* Call's user handler (if available) for CatchAll.
*
* @access private
* @param String $data Raw message from server
* @return void
*/
function CatchAll($data)
{
//Add to a log of unsupported messages.
$this->unsupported[] = $data;
//$this->log($data);
//print_r($data);
$this->callHandler("CatchAll", $data);
}
/**
* Calls User Handler
*
* Calls registered handler for a specific event.
*
* @access private
* @param String $event Command (event) name (Rvous etc)
* @param String $data Raw message from server
* @see registerHandler
* @return void
*/
function callHandler($event, $data)
{
if (isset($this->myEventHandlers[$event]))
{
//$function = $this->myEventHandlers[$event] . "(\$data);";
//eval($function);
call_user_func($this->myEventHandlers[$event], $data);
}
else
{
$this->noHandler($data);
}
}
/**
* Registers a user handler
*
* Handler List
* SignOn, Config, ERROR, NICK, IMIn, UpdateBuddy, Eviled, Warned, ChatJoin
* ChatIn, ChatUpdate, ChatInvite, ChatLeft, GotoURL, DirStatus, AdminNick
* AdminPasswd, Pause, Rvous, DimIn, CatchAll
*
* @access private
* @param String $event Event name
* @param String $handler User function to call
* @see callHandler
* @return boolean Returns true if successful
*/
function registerHandler($event, $handler)
{
if (is_callable($handler))
{
$this->myEventHandlers[$event] = $handler;
return true;
}
else
{
return false;
}
}
/**
* No user handler method fall back.
*
* Does nothing with message.
*
* @access public
* @param String $message Raw server message
* @return void
*/
function noHandler($message)
{
//This function intentionally left blank
//This is where the handlers will fall to for now. I plan on including a more
//efficent check to avoid the apparent stack jumps that this code will produce
//But for now, just fall into here, and be happy
return;
}
//GLOBAL FUNCTIONS
/**
* Finds type, and returns as part of array ['type']
* Puts message in ['incoming']
*
* Helper method for getMessageInfo.
*
* @access public
* @param String $message Raw server message
* @see msg_parse
* @see getMessageInfo
* @return array
*/
static function msg_type($message)
{
$command = array();
@list($cmd, $rest) = explode(":", $message);
switch($cmd)
{
case 'IM_IN2':
$type = AIM_TYPE_MSG;
break;
case 'UPDATE_BUDDY2':
$type = AIM_TYPE_UPDATEBUDDY;
break;
case 'EVILED':
$type = AIM_TYPE_WARN;
break;
case 'SIGN_ON':
$type = AIM_TYPE_SIGNON;
break;
case 'NICK':
$type = AIM_TYPE_NICK;
break;
case 'ERROR':
$type = AIM_TYPE_ERROR;
break;
case 'CHAT_JOIN':
$type = AIM_TYPE_CHATJ;
break;
case 'CHAT_IN':
$type = AIM_TYPE_CHATI;
break;
case 'CHAT_UPDATE_BUDDY':
$type = AIM_TYPE_CHATUPDBUD;
break;
case 'CHAT_INVITE':
$type = AIM_TYPE_CHATINV;
break;
case 'CHAT_LEFT':
$type = AIM_TYPE_CHATLE;
break;
case 'GOTO_URL':
$type = AIM_TYPE_URL;
break;
case 'ADMIN_NICK_STATUS':
$type = AIM_TYPE_NICKSTAT;
break;
case 'ADMIN_PASSWD_STATUS':
$type = AIM_TYPE_PASSSTAT;
break;
case 'RVOUS_PROPOSE':
$type = AIM_TYPE_RVOUSP;
break;
default:
$type = AIM_TYPE_NOT_IMPLEMENTED;
break;
}
$command['type'] = $type;
$command['incoming'] = $message;
return $command;
}
/**
* Parses message and splits into info array
*
* Helper method for getMessageInfo.
*
* @access public
* @param String $command Message and type (after msg_type)
* @see msg_type
* @see getMessageInfo
* @return array
*/
static function msg_parse($command)
{
$info = array();
switch($command['type'])
{
case AIM_TYPE_WARN:
$command['incoming'] .= ":0";
$it = explode(":", $command['incoming']);
$info['warnlevel'] = $it[1];
$info['from'] = $it[2];
break;
case AIM_TYPE_MSG:
$it = explode(":", $command['incoming'],5);
$info['auto'] = $it[2];
$info['from'] = $it[1];
$info['message'] = $it[4];
break;
case AIM_TYPE_UPDATEBUDDY:
@list($cmd, $info['sn'], $info['online'], $info['warnlevel'], $info['signon'], $info['idle'], $info['uc']) = explode(":", $command['incoming']);
break;
case AIM_TYPE_SIGNON:
@list($cmd, $info['version']) = explode(":", $command['incoming']);
break;
case AIM_TYPE_NICK:
@list($cmd, $info['nickname']) = explode(":", $command['incoming']);
break;
case AIM_TYPE_ERROR:
@list($cmd, $info['errorcode'], $info['args']) = explode(":", $command['incoming']);
break;
case AIM_TYPE_CHATJ:
@list($cmd, $info['chatid'], $info['chatname']) = explode(":", $command['incoming']);
break;
case AIM_TYPE_CHATI:
@list($cmd, $info['chatid'], $info['user'], $info['whisper'], $info['message']) = explode(":", $command['incoming'],5);
break;
case AIM_TYPE_CHATUPDBUD:
@list($cmd, $info['chatid'], $info['inside'], $info['userlist']) = explode(":", $command['incoming'],3);
break;
case AIM_TYPE_CHATINV:
@list($cmd, $info['chatname'], $info['chatid'], $info['from'], $info['message']) = explode(":", $command['incoming'],5);
break;
case AIM_TYPE_CHATLE:
@list($cmd, $info['chatid']) = explode(":", $command['incoming']);
break;
case AIM_TYPE_URL:
@list($cmd, $info['windowname'], $info['url']) = explode(":", $command['incoming'],3);
break;
case AIM_TYPE_RVOUSP:
@list($cmd,$info['user'],$info['uuid'],$info['cookie'],$info['seq'],$info['rip'],$info['pip'],$info['vip'],$info['port'],$info['tlvs']) = explode(":",$command['incoming'],10);
break;
case AIM_TYPE_NICKSTAT:
case AIM_TYPE_PASSSTAT:
@list($cmd, $info['returncode'], $info['opt']) = explode(":", $command['incoming'],3);
break;
default:
$info['command'] = $command['incoming'];
}
return $info;
}
/**
* Returns a parsed message
*
* Calls msg_parse(msg_type( to first determine message type and then parse accordingly
*
* @access public
* @param String $command Raw server message
* @see msg_type
* @see msg_parse
* @return array
*/
static function getMessageInfo($message)
{
return self::msg_parse(self::msg_type($message));
}
/**
* Checks socket for end of file
*
* @access public
* @param Resource $socket Socket to check
* @return boolean true if end of file (socket)
*/
static function socketcheck($socket){
$info = stream_get_meta_data($socket);
return $info['eof'];
//return(feof($socket));
}
}
?>
Reference in New Issue View Git Blame Copy Permalink