public function connect($address = "", $port = "")
{
if ($this->connected) {
$this->close();
}
if (empty($port) || !is_integer($port)) {
$port = config::$walletPort;
}
if (empty($address)) {
$address = config::$networkInterface;
}
$address = gethostbyname($address);
$this->address = $address;
$this->port = $port;
$this->socket = @socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
if ($this->socket === false) {
gio::log("" . socket_strerror(socket_last_error()), E_USER_WARNING);
return false;
}
$result = @socket_connect($this->socket, $this->address, $this->port);
if ($result === false) {
gio::log("" . socket_strerror(socket_last_error($this->socket)), E_USER_WARNING);
return false;
}
$this->connectmessage = @socket_read($this->socket, config::$maximumTransmissionLength, PHP_NORMAL_READ);
$this->connected = true;
return true;
}
public static function extract($msg)
{
if (!is_string($msg)) {
return $msg;
}
gio::log("Extracting message ...");
$extract = json_decode(base64_decode($msg), true);
gio::log("... Done Extracting message");
return $extract;
}
public static function makepath($arr)
{
$l = count($arr);
$path = "";
for ($i = 1; $i <= $l; $i++) {
$path .= $arr[$i - 1];
if ($i != $l) {
$path .= DS;
}
}
gio::log("Created file path: {$path}", VERBOSE);
return $path;
}
public function doload($ref = "")
{
$ref = $ref ? $ref : config::$walfile;
$loc = Tools::makepath(array("wal", "{$ref}"));
switch ($ref) {
case "wal":
$ret = unserialize(gio::readfile(Tools::makepath(array("wal", "{$ref}"))));
magic::proc($ret, false);
break;
default:
$ret = unserialize(gio::readfile($loc));
}
return $ret;
}
public static function load($ref = null)
{
$ref = $ref ? $ref : config::$walfile;
/*$s = __class__;
$engine = config::$storageengine.$s;
$s = new $s;
aggregate($s,$engine);
$ret = $s->doload($ref);*/
$loc = Tools::makepath(array("wal", "{$ref}"));
$ret = unserialize(gio::readfile($loc));
if ($ref == config::$walfile) {
magic::proc($ret, false);
}
return $ret;
}
function main($mainmsg)
{
gio::output(config::$walletMessage);
$serv = popen("service.ecsh", 'r');
$net = new Gnet();
$inerr = 0;
while (true) {
if (!$inerr) {
gio::output();
foreach ($mainmsg as $k => $v) {
gio::output("{$k} - {$v}");
}
gio::output();
$msg = "Enter your choice and press enter";
}
$inerr = 0;
$c = gio::input("{$msg}");
switch ($c) {
case 1:
$tid = gio::input("Enter the transaction Id");
$st = transaction::status($tid);
if (!$st) {
gio::output("Transaction reference '{$tid}' not found");
} else {
$rpt['order id'] = $st['order id'];
$rpt['order amount'] = $st['amount'];
$rpt['from'] = $st['client'];
$rpt['to'] = $st['merchant'];
$rpt['transaction time'] = date(config::$timeFormat, $st['acknowledgement']['completed']);
$rpt['description'] = $st['description'];
$rpt['transaction reference'] = $st['acknowledgement']['id'];
$rpt['response code'] = $st['acknowledgement']['status'];
$rpt['response message'] = $st['acknowledgement']['message'];
$rpt['ecash value tendered'] = $st['acknowledgement']['amount'];
$rpt['ecash tendered'] = $st['acknowledgement']['ecashids'];
gio::display($rpt);
if (gio::confirm("Do you want to save the report to a file")) {
$dest = gio::input("Enter full path to the file");
gio::display($rpt, $x);
if (!gio::saverawfile(join("\r\n", $x), $dest)) {
gio::output("Could not save the report to {$dest}");
} else {
gio::output("Report successfully saved to {$dest}");
}
unset($x);
}
}
break;
case 2:
$maxallowed = 1000;
$v = gio::input("What value of eCash do you wish to mine", "integer");
$n = gio::input("How many eCashes do you wish to mine", "integer");
$c = mine::countcoins($null);
unset($null);
if ($n > $maxallowed || $c + $n > $maxallowed) {
$rem = $maxallowed - $c;
gio::output("You can not mine above {$maxallowed} eCashes!");
gio::output("You can mine {$rem} more eCashes!");
} else {
$res = mine::coins($n, $v);
if ($res) {
gio::output("You have successfully mined {$n} eCashes.");
gio::output("Mining process took " . Tools::arrtostr($res, ", "));
} else {
gio::output("Mining operation failed!");
}
}
break;
case 3:
$n = mine::countcoins($coins);
gio::output("A total of {$n} eCash value is available");
if ($n && gio::confirm("Do you wish to see their Id's")) {
foreach ($coins as $val => $ccs) {
foreach ($ccs as $i => $coin) {
gio::output("Ecash ID: {$i}");
foreach ($coin as $id => $c) {
if ($id == "token") {
$c = md5($c);
}
if ($id == "hash") {
$c = sha1($c);
}
if ($id == "mined") {
$c = date(config::$timeFormat, $c);
}
gio::output("{$id}=>{$c}");
}
gio::output();
}
}
}
break;
case 4:
$to = gio::input("Enter the wallet address");
$amt = gio::input("Enter the amount to give");
$res = account::give($to, $amt);
break;
case "x":
$net->connect(config::$serviceAddress, intval(config::$servicePort));
$net->send("shutdown");
if ($serv) {
$ret = pclose($serv);
}
break 2;
default:
$inerr = 1;
$msg = "Retry";
}
if (!$inerr) {
gio::output("\n\n\n");
}
}
if (isset($ret) && $ret != 0) {
gio::output("An error occured while exiting...");
}
gio::output(config::$exitMessage);
sleep(3);
}
private static function hash($in)
{
$h = new ghash("{$in}", 20);
$token = '';
try {
$token = $h->hash();
} catch (Exception $e) {
gio::log('ERROR: ' . $e->getMessage());
}
unset($h);
return $token;
}
public static function certexchange($addr)
{
$d = Tools::address($addr);
if (file_exists(GsonCrypt::getcert($d['bank']))) {
return true;
}
$c = GsonCrypt::getcert(null, true);
$m = Gmsg::create(Gmsg::prepare($c, 'exchangecert', $d['bank']));
$net = new Gnet();
$r = $net->connect($d['address'], intval($d['port']));
if (!$r) {
return false;
}
$r = $net->send($m);
if (!$r) {
return false;
}
$r = Gmsg::extract($r);
if (!$r) {
return false;
}
if ($r['status']) {
$resp = gio::saverawfile($r['cert'], GsonCrypt::getcert($d['bank']));
}
return isset($resp) ? $resp : false;
}
function main($mainmsg)
{
gio::output(config::$walletMessage);
$net = new Gnet();
$inerr = 0;
while (true) {
$inmsg = array();
if (account::isCreated()) {
$inmsg["d"] = "Destroy Account";
$dmsg = $mainmsg + $inmsg;
} else {
$inmsg["c"] = "Create Wallet Account [Merchant/Client]";
$dmsg = $inmsg;
}
$dmsg["x"] = "Exit";
if (!$inerr) {
gio::output();
foreach ($dmsg as $k => $v) {
$k = strtoupper($k);
gio::output("{$k} - {$v}");
}
gio::output();
$msg = "Enter your choice and press enter";
}
$inerr = 0;
$c = gio::input("{$msg}");
if (!array_key_exists($c, $dmsg)) {
$c = null;
}
switch ($c) {
case 1:
$a = account::address();
gio::output("Your wallet address is: {$a}");
break;
case 2:
$m = transaction::request();
gio::output($m[1]);
break;
case 3:
transaction::grant();
break;
case 4:
$n = account::balance($coins);
gio::output("Total value of eCash units: {$n}");
if ($n && gio::confirm("Do you wish to see their Id's")) {
foreach ($coins as $val => $ccs) {
foreach ($ccs as $i => $coin) {
gio::output("Ecash ID: {$i}");
foreach ($coin as $id => $c) {
if ($id == "token") {
$c = md5($c);
}
if ($id == "hash") {
$c = sha1($c);
}
if ($id == "mined") {
$c = date(config::$timeFormat, $c);
}
gio::output("{$id}=>{$c}");
}
gio::output();
}
}
}
break;
case 5:
$o = gio::input("Enter the order id [EMPTY for all]");
$f = null;
if (gio::confirm("Do you want to create a file on your desktop")) {
do {
$f = gio::input("Enter the file name");
} while (!$f);
}
transaction::reports($o, $f);
break;
case 6:
transaction::clearallrequests();
break;
case 7:
account::merckey(gio::input("Enter the name of the file to write to your desktop"));
break;
case 8:
$maxallowed = 1000;
$v = gio::input("What value of eCash do you wish to mine", "integer");
$n = gio::input("How many eCashes do you wish to mine", "integer");
$c = mine::countcoins($null);
unset($null);
if ($n > $maxallowed || $c + $n > $maxallowed) {
$rem = $maxallowed - $c;
gio::output("You can not mine above {$maxallowed} eCashes!");
gio::output("You can mine {$rem} more eCashes!");
} else {
$res = mine::ecash($n, $v);
if ($res) {
gio::output("You have successfully mined {$n} eCashes.");
gio::output("Mining process took " . Tools::arrtostr($res, ", "));
} else {
gio::output("Mining operation failed!");
}
}
break;
case "c":
account::create();
break;
case "d":
gio::output("This action will irreversibly destroy your wallet and its contents");
if (gio::confirm("Are you sure you want to destroy your account")) {
account::destroy();
}
break;
case "x":
$net = null;
break 2;
default:
$inerr = 1;
$msg = "Retry";
}
if (!$inerr) {
gio::output("\n\n\n");
}
}
if (isset($ret) && $ret != 0) {
gio::output("An error occured while exiting...");
}
gio::output(config::$exitMessage);
sleep(3);
}
public static function give($to, $amt)
{
$ramt = $amt;
$rem = mine::countcoins($coins);
if ($rem < $amt) {
gio::output("Not enough coins");
return false;
}
$paths = Tools::address($to);
if (!$paths) {
gio::output("The destination account is invalid");
return false;
}
$getcoins = array();
$c = 1;
if (!is_array($coins)) {
return false;
}
$vals = array_keys($coins);
rsort($vals);
foreach ($vals as $val) {
if ($amt < $val) {
continue;
}
if ($amt <= 0) {
break;
}
$ch[$val] = floor($amt / $val);
if ($ch[$val] > count($coins[$val])) {
$ch[$val] = count($coins[$val]);
}
$amt -= $ch[$val] * $val;
}
foreach ($ch as $v => $n) {
while ($n > 0 && (list($id, $coin) = each($coins[$v]))) {
$getcoins[$id] = $coin;
unset($coins[$v][$id]);
$n--;
}
}
foreach ($getcoins as $k => $v) {
$secret[$k] = Tools::makesecrets();
$getcoins[$k]['secret'] = GsonCrypt::seal($secret[$k], $paths['srakey']);
}
$net = new Gnet();
if (!$net->connect($paths['address'], intval($paths['port']))) {
gio::output("Unable to connect to the destination account");
return false;
} else {
$m = Gmsg::create(Gmsg::prepare($getcoins, "deposit", $paths['account']));
$m = GsonCrypt::seal($m, $paths['bank']);
if (!$m) {
gio::output("Unable to send!");
gio::output("POSSIBLE CAUSES:");
gio::output("The destination bank's certificate is not avaiable!");
gio::output("Account may not be registered with sra!");
gio::output("Account may have been deregistered with sra!");
return false;
}
$r = $net->send($m);
$s = GsonCrypt::unseal($r);
$r = $s ? Gmsg::extract($s) : Gmsg::extract($r);
unset($net);
if (!$r || !$r['status']) {
gio::output("Deposit of {$ramt} coins to {$to} Failed!");
gio::output($r['response']);
return false;
} else {
$old = storage::load($paths['srakey']);
foreach ($getcoins as $id => $coin) {
$getcoins[$id]['secret'] = $secret[$id];
$val = $coin['value'];
$old[$val][$id] =& $getcoins[$id];
}
storage::save($old, $paths['srakey']);
storage::save($coins);
gio::output("Deposit of {$ramt} coins to {$to} was successful");
return true;
}
}
}
public static function reports($oid = 0, $file = "")
{
$r = self::status($oid);
if (!$r[0]) {
gio::output($r[1]);
} else {
foreach ($r[1] as $oid => $o) {
$w = array();
$w['order id'] = $oid;
$w['order amount'] = $o['amount'] . " units";
$w['description'] = $o['description'];
$w['time of transaction'] = date(config::$timeFormat, $o['acknowledgement']['completed']);
$w['transaction reference'] = $o['acknowledgement']['id'];
$w['response code'] = $o['acknowledgement']['status'];
$w['response message'] = $o['acknowledgement']['message'];
$w['ecash value tendered'] = $o['acknowledgement']['amount'] . " units";
$w['ecash tendered'] = $o['acknowledgement']['ecashids'];
if (isset($o['acknowledgement']['rejectedecash'])) {
$w['ecash rejected'] = $o['acknowledgement']['rejectedecash'];
}
$w['from'] = $o['client'];
$w['to'] = $o['merchant'];
if ($file) {
gio::display($w, $wr[]);
} else {
gio::output();
gio::display($w);
gio::output();
}
}
if ($file) {
foreach ($wr as $k => $v) {
$wr[$k] = join("\r\n", $wr[$k]);
}
$file .= ".txt";
$ofile = Tools::makepath(array(getenv('USERPROFILE'), "Desktop", "{$file}"));
if (gio::saverawfile(join("\r\n\r\n\r\n", $wr), $ofile)) {
gio::output("The file {$file} was sucessfully written to your desktop");
} else {
gio::output("Error while writing {$file} to your desktop");
}
}
}
}
private static function hash($in)
{
switch (config::$minestrength) {
case 1:
$s = 22;
break;
case 2:
$s = 25;
break;
case 3:
$s = 28;
break;
case 4:
$s = 32;
break;
case 5:
$s = 35;
break;
case 6:
$s = 40;
break;
case 7:
$s = 50;
default:
$s = 20;
}
$h = new ghash("{$in}", $s);
$token = '';
try {
$token = $h->hash();
} catch (Exception $e) {
gio::log('ERROR: ' . $e->getMessage());
}
unset($h);
return $token;
}
public function parseStamp($stamp)
{
if (!$stamp) {
gio::log('Stamp "' . $stamp . '" is not valid.', E_USER_ERROR);
}
$items = preg_split('/:/', $stamp);
if (count($items) < 7) {
gio::log('Stamp "' . $stamp . '" is not valid.', E_USER_ERROR);
}
$this->setVersion($items[0]);
$this->setBits($items[1]);
$this->setDate($items[2]);
$this->setResource($items[3]);
$this->setExtension($items[4]);
$this->setSalt($items[5]);
$this->setSuffix($items[6]);
}
public static function cryptoInstalled()
{
gio::log("Checking Cryptographic library Installation ...", VERBOSE);
if (function_exists("openssl_pkey_new")) {
gio::log("... Cryptographic library Installation OK", VERBOSE);
return true;
}
gio::log("... Cryptographic library Not Installed ...", E_USER_WARNING);
return false;
}
public static function configsvc()
{
$cfg[0] = gio::input("Enter the interface to run on [127.0.0.1]");
if (empty($cfg[0])) {
$cfg[0] = "127.0.0.1";
}
$cfg[1] = gio::input("Enter the port to run on [11000]");
if (empty($cfg[1])) {
$cfg[1] = 11000;
}
gio::savetofile(serialize($cfg), config::$svcCfgFile);
}
function main($mainmsg)
{
gio::output(config::$walletMessage);
if (account::isCreated()) {
$serv = popen("service.ecsh", 'r');
}
$net = new Gnet();
$inerr = 0;
while (true) {
$inmsg = array();
if (account::isCreated()) {
$inmsg["d"] = "Destroy Account";
$dmsg = $mainmsg + $inmsg;
} else {
$inmsg["c"] = "Create Bank Wallet";
$dmsg = $inmsg;
}
$dmsg["x"] = "Exit";
if (!$inerr) {
gio::output();
foreach ($dmsg as $k => $v) {
$k = strtoupper($k);
gio::output("{$k} - {$v}");
}
gio::output();
$msg = "Enter your choice and press enter";
}
$inerr = 0;
$c = gio::input("{$msg}");
if (!array_key_exists($c, $dmsg)) {
$c = null;
}
switch ($c) {
case 1:
$a = account::address();
gio::output("Bank's account address is: {$a}");
break;
case 2:
$n = account::coins(config::$accountId, $coins);
gio::output("You have {$n} coins");
if ($n && gio::confirm("Do you wish to see their Id's")) {
foreach ($coins as $val => $ccs) {
foreach ($ccs as $i => $coin) {
gio::output("Ecash ID: {$i}");
foreach ($coin as $id => $c) {
if ($id == "token") {
$c = md5($c);
}
if ($id == "hash") {
$c = sha1($c);
}
if ($id == "mined") {
$c = date(config::$timeFormat, $c);
}
gio::output("{$id}=>{$c}");
}
gio::output();
}
}
}
break;
case 3:
$m = transaction::prequest();
gio::output($m[1]);
break;
case 4:
transaction::pgrant();
break;
case 5:
$acc = gio::input("Enter the wallet number [EMPTY for bank's self]");
$o = gio::input("Enter the order id [EMPTY for all]");
$f = null;
if (gio::confirm("Do you want to create a file on your desktop")) {
do {
$f = gio::input("Enter the file name");
} while (!$f);
}
transaction::reports($o, $acc, $f);
break;
case 6:
$m = transaction::clearrequests(null, null);
gio::output($m[1]);
break;
case 7:
account::merckey(gio::input("Enter the name of the file to write to your desktop"));
break;
case "c":
$serv = account::create();
break;
case "d":
gio::output("This action will irreversibly destroy your wallet and its contents");
if (gio::confirm("Are you sure you want to destroy your account")) {
account::destroy();
}
break;
case "x":
@$net->send('shutdown');
$net = null;
if ($serv) {
$ret = pclose($serv);
}
break 2;
default:
$inerr = 1;
$msg = "Retry";
}
if (!$inerr) {
gio::output("\n\n\n");
}
}
if (isset($ret) && $ret != 0) {
gio::output("An error occured while exiting...");
}
gio::output(config::$exitMessage);
sleep(3);
}
public static function merckey($file = "")
{
$s = GsonCrypt::sign(md5(gio::readfile(GsonCrypt::getcert())));
if ($file) {
$file .= ".txt";
$ofile = Tools::makepath(array(getenv('USERPROFILE'), "Desktop", "{$file}"));
if (gio::saverawfile("MERCHANT/ACCOUNT KEY: '{$s}'", $ofile)) {
gio::output("The file {$file} was sucessfully written to your desktop");
} else {
gio::output("Error while writing {$file} to your desktop");
}
} else {
return $s;
}
}
public static function readrawfile($file)
{
gio::log("Reading rawfile: {$file} ...", VERBOSE);
$ret = @file_get_contents($file);
if (!$ret) {
gio::log("... Error reading rawfile: {$file} ...", E_USER_WARNING);
} else {
gio::log("... Done reading rawfile: {$file}", VERBOSE);
}
return $ret;
}
private static function register()
{
if (self::isRegistered()) {
return true;
}
$ba = Tools::address(gio::input("Enter the bank's address"));
if (!$ba) {
return false;
}
config::$bankAddress = $ba['address'];
config::$bankPort = intval($ba['port']);
$net = new Gnet();
$r = $net->send(Gmsg::create(Gmsg::prepare("", "register", config::$bankId)));
$net = null;
if (!$r) {
return false;
}
$m = Gmsg::extract($r);
if (!$m['status']) {
return false;
}
if (gio::saverawfile($m['cert'], GsonCrypt::getcert($m['name'])) && gio::savetofile($m['cert'], GsonCrypt::getkey($m['name']))) {
if (gio::savetofile($m['name'], config::$bankIdFile) && gio::savetofile(serialize(array(config::$bankAddress, config::$bankPort)), config::$walCfgFile)) {
config::$bankId = $m['name'];
config::$accountId = $m['account'];
return true;
} else {
self::deregister();
return false;
}
}
return false;
}
private function _processrequest()
{
if (($this->msgsock = @socket_accept($this->sock)) === false) {
gio::log("socket_accept() failed: reason: " . socket_strerror(socket_last_error($this->sock)), E_USER_ERROR);
break;
}
gio::log("\nSocket: CONNECTION RECEIVED", VERBOSE);
$this->_welcome();
do {
if (false === ($buf = @socket_read($this->msgsock, config::$maximumTransmissionLength, PHP_NORMAL_READ))) {
gio::log("socket_read() failed: reason: " . socket_strerror(socket_last_error($this->msgsock)), E_USER_WARNING);
break;
}
if (!($buf = trim($buf))) {
continue;
}
gio::log("NEW REQUEST RECEIVED", VERBOSE);
if ($buf == 'quit') {
gio::log("Socket: Connection terminated by client!", VERBOSE);
break;
}
if ($buf == 'restart') {
$this->restart = true;
gio::log("Socket: Restarting the server !!!", VERBOSE);
$buf = 'shutdown';
}
if ($buf == 'shutdown') {
gio::output("Processing request to stop the server ...");
self::_out("Shuting down...");
self::_flush();
$this->stop = true;
break;
}
if (!$this->stop) {
$sockreply = Gmsg::process($buf);
$this->_out($sockreply);
$this->_flush();
gio::log("Socket: REPLY SENT\n", VERBOSE);
} else {
$this->_out("...Terminating Server Process...");
break;
}
} while (true);
socket_close($this->msgsock);
unset($this->msgsock);
gio::log("\nSocket: CONNECTION ENDED", VERBOSE);
}
public static function process($msg)
{
$status = 1;
$sender = "";
$res = "";
$umsg = GsonCrypt::unseal($msg);
if (!$umsg) {
$ex = Gmsg::extract($msg);
if ($ex && is_array($ex)) {
$umsg = $msg;
} else {
$status = 0;
$res = "Unable to decode the message";
}
}
if ($umsg) {
$parts = self::extract($umsg);
$action = $parts["op"];
$mess = $parts["msg"];
$sender = $parts["sender"];
$recipient = $parts["recipient"];
if ($recipient && !account::exists($recipient)) {
$status = 0;
$res = "The recipient account {$recipient} does not reside here";
$rply = Gmsg::create(array("status" => $status, "response" => $res));
} else {
switch ($action) {
case "mrequest":
$r = transaction::request($mess['m'], $sender, $mess['k']);
$rply = Gmsg::create(array("status" => $r[0], "response" => $r[1]));
break;
case "mstatus":
$r = transaction::mercorder($mess['m'], $sender, $mess['k']);
$rply = Gmsg::create(array("status" => $r[0], "response" => $r[1]));
break;
case "statusrequest":
$r = transaction::status($mess, $sender);
$m = Gmsg::create(array("status" => $r[0], "response" => $r[1]));
$rply = GsonCrypt::sign($m);
break;
case "paymentrequest":
$r = transaction::request($mess, $sender);
$m = Gmsg::create(array("status" => $r[0], "response" => $r[1]));
$rply = GsonCrypt::sign($m);
break;
case "pullrequests":
$r = transaction::pullrequests($mess, $sender);
$m = Gmsg::create(array("status" => $r[0], "response" => $r[1]));
$rply = GsonCrypt::sign($m);
break;
case "pullcoins":
$r = account::pullcoins($mess, $sender);
$m = Gmsg::create(array("status" => $r[0], "response" => $r[1]));
$rply = GsonCrypt::sign($m);
break;
case "clearrequests":
$r = transaction::clearrequests($mess, $sender);
$m = Gmsg::create(array("status" => $r[0], "response" => $r[1]));
$rply = GsonCrypt::sign($m);
break;
case "notification":
$r = transaction::notification($mess, $sender);
$m = Gmsg::create(array("status" => $r[0], "response" => $r[1]));
$rply = GsonCrypt::sign($m);
break;
case "acknowledgement":
$r = transaction::acknowledgement($mess, config::$SRA);
$m = Gmsg::create(array("status" => $r[0], "response" => $r[1]));
$rply = GsonCrypt::sign($m);
break;
case "deposit":
$r = account::deposit($mess, $recipient);
if (!$r) {
$status = 0;
$res = "Deposit failed";
} else {
$res = "Deposit was successful";
}
break;
case "revokecert":
$net = new Gnet();
$rply = $net->send("{$mess}", true);
$net = null;
break;
case "signcert":
$net = new Gnet();
$rply = $net->send("{$mess}", true);
$net = null;
break;
case "register":
$k = GsonCrypt::getcert();
if (is_readable($k)) {
$res = gio::readfile($k);
if (!$res) {
$status = 0;
}
}
$rply = Gmsg::create(array("status" => $status, "cert" => $res, "name" => config::$accountId, "account" => account::makenew()));
break;
case "create":
$status = gio::savetofile($mess, GsonCrypt::getkey("{$sender}"));
$res = $status ? "successful" : "failed";
$rply = Gmsg::create(array("status" => $status, "response" => $res));
break;
case "remove":
$res = "";
$ret = array("status" => $status, "response" => $res);
$rply = self::create($ret);
$rply = GsonCrypt::seal("{$rply}", "{$sender}");
unlink(GsonCrypt::getkey($sender));
break;
case "exchangecert":
$status = 0;
if (!file_exists(GsonCrypt::getcert("{$sender}"))) {
$status = gio::saverawfile($mess, GsonCrypt::getcert("{$sender}"));
}
$k = GsonCrypt::getcert();
if ($status && is_readable($k)) {
$res = gio::readfile($k);
if (!$res) {
$status = 0;
}
}
$rply = Gmsg::create(array("status" => $status, "cert" => $res));
break;
case "reverb":
$res = $mess;
break;
default:
$status = 0;
$res = "Invalid Operation!";
}
}
}
if (!isset($rply)) {
$ret = array("status" => $status, "response" => $res);
$rply = self::create($ret);
$rply = $sender ? GsonCrypt::seal("{$rply}", "{$sender}") : "{$rply}";
}
return $rply;
}
