lib/interComms.php

   1 <?php
   2 define("NETCOM_PORT", 14001);
   3 define("NETCOM_PORT_SSL", 14002);
   4
   5
   6 // comms on this thing are very serial, the server are only capable of processing
   7 // one thing at a time... for now
   8
   9 // the encryption we use here yes, it will be pub/priv but not ssl per se.
  10 // how encryption works:
  11 // initiate connection:
  12 // server -> PEN:b64enc(pubkey):INE
  13 // client -> PEN:ACK:INE
  14 // client -> PEN:encrypt(pubkey, session key):INE
  15 // server -> PEN:ACK:INE
  16 // client -> PEN:encrypt(data, session key):INE <-- data transmission starts here
  17 // server -> PEN:ACK:INE
  18
  19 class netCom {
  20
  21         function __construct($am_i_a_server = false, $server_addr = "127.0.0.1", $secure = false)
  22         {
  23                 global $storeLocation;
  24
  25                 // i have to set it to something, right?
  26                 $this->semKey = ftok(__FILE__, "p");
  27                 $this->encrypt = $secure;
  28
  29                 $this->amserver = $am_i_a_server;
  30                 $this->server = $server_addr;
  31
  32                 $this->secure_server = $secure;
  33
  34                 // this bit needs to be a bit more modular
  35                 if($this->amserver && $this->secure_server) if(is_file("$storeLocation/mykey.priv")) {
  36                         echo "loading key\n";
  37                         $kh = fopen("$storeLocation/mykey.priv", "r");
  38                         $kdp = fread($kh, filesize("$storeLocation/mykey.priv"));
  39
  40                         $key = openssl_pkey_get_private($kdp);
  41                         $output = "";
  42                         $km = openssl_pkey_export($key, $output);
  43                         echo "key is $output\n";
  44                         $this->key_priv = $output;
  45
  46                         $ar_pubkey = openssl_pkey_get_details($key);
  47                         $this->key_pub = $ar_pubkey["key"];
  48
  49
  50                 } else {
  51                         echo "generateing key\n";
  52                         $key = openssl_pkey_new();
  53                         echo "key generated $key\n";
  54                         $output = "";
  55                         $km = openssl_pkey_export($key, $output);
  56                         echo "key is $output\n";
  57                         $ar_pubkey = openssl_pkey_get_details($key);
  58                         $pubkey = $ar_pubkey["key"];
  59                         echo "array is $pubkey\n";
  60                         // now lets write some shit
  61                         $priv_f = fopen("$storeLocation/mykey.priv", "w");
  62                         fwrite($priv_f, $output);
  63                         $this->key_priv = $output;
  64                         fclose($priv_f);
  65
  66                         $pub_f = fopen("$storeLocation/mykey.pub", "w");
  67                         fwrite($pub_f, $pubkey);
  68                         $this->key_pub = $pubkey;
  69                         fclose($pub_f);
  70
  71
  72                 }
  73         }
  74
  75         // initiates a bind if its a server, a connect if its a client
  76         function go($callback = "")
  77         {
  78                 if($this->amserver) {
  79                         echo "i am a server, bind!\n";
  80                         // here we fork our server
  81                         $pid = pcntl_fork();
  82                         if($pid == -1) {
  83                                 return false;
  84                                 // fork failure
  85                         } else if ($pid) {
  86                                 return true;
  87                                 // parent
  88                         } else {
  89                                 // child
  90                                 if($this->secure_server) {
  91                                         $this->startSecureServerListener($callback);
  92                                 } else {
  93                                         $this->startServerListener($callback);
  94                                 }
  95                         }
  96                 } else {
  97                         echo "I am a client, connect!\n";
  98                         if($this->secure_server) {
  99                                 $this->socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
 100                                 $res = socket_connect($this->socket, $this->server, NETCOM_PORT_SSL);
 101                         } else {
 102                                 $this->socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
 103                                 $res = socket_connect($this->socket, $this->server, NETCOM_PORT);
 104
 105                         }
 106                 }
 107         }
 108
 109         function startSecureServerListener($callback)
 110         {
 111                 $this->listen_socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
 112                 socket_bind($this->listen_socket, $this->server, NETCOM_PORT_SSL);
 113                 socket_listen($this->listen_socket);
 114
 115                 while(true) {
 116                         $newsock = socket_accept($this->listen_socket);
 117                         echo "Have a new conneciton\n";
 118                         // i now have a connection
 119                         $pid = pcntl_fork();
 120                         if($pid == -1) return false;
 121                         else if (!$pid) {
 122                                 secureConnection($callback, $newsock);
 123                         }
 124                 }
 125         }
 126
 127         function secureConnection($callback, $socket)
 128         {
 129                 // when the secure conneciton starts, we send out pub key
 130                 sendMessageInternal($this->key_pub, $socket);
 131
 132                 // then we get a session key
 133                 $sesskey_enc = receiveMessageInternal($socket);
 134
 135                 // which we decrypt using our priv key and store.
 136                 $this->session_key = openssl_private_decypt();
 137
 138                 // now we go into a message loop.
 139         }
 140
 141         function startServerListener($callback)
 142         {
 143                 $this->listen_socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
 144                 socket_bind($this->listen_socket, $this->server, NETCOM_PORT);
 145                 socket_listen($this->listen_socket);
 146
 147                 while(true) {
 148                         $newsock = socket_accept($this->listen_socket);
 149                         echo "Have a new conneciton\n";
 150                         // i now have a connection
 151                         $pid = pcntl_fork();
 152                         if($pid == -1) return false;
 153                         else if (!$pid) {
 154                                 $this->insecureConnection($callback, $newsock);
 155                         }
 156                 }
 157         }
 158
 159         function insecureConnection($callback, $socket)
 160         {
 161                 $continue = true;
 162                 while($continue) {
 163                         // wait for a message
 164                         $msg = unserialize($this->receiveMessageInternal($socket));
 165                         $retmsg = $callback($msg);
 166                         $retval = $this->sendMessageInternal(serialize($retmsg), $socket);
 167                         if(!$retval) {
 168                                 echo "Connection handler dieing\n";
 169                                 $continue = false;
 170                         }
 171                 }
 172         }
 173
 174         function sendMessage($data)
 175         {
 176                 $continue = true;
 177
 178                 $returned = false;
 179                 if($this->secure_server) {
 180                         $returned = $this->sendMessageSecure($data);
 181                 } else {
 182                         $returned = $this->sendMessageInsecure($data);
 183                 }
 184
 185                 return $returned;
 186         }
 187
 188         function sendMessageInsecure($data)
 189         {
 190                 $returned = $this->sendMessageInternal(serialize($data), $this->socket);
 191
 192                 return unserialize($returned);
 193         }
 194
 195         function sendMessageInternal($message_data, $comsock)
 196         {
 197                 echo "begin send message\n";
 198                 $datacomp = base64_encode($message_data);
 199                 $tosend = "PEN:$datacomp:INE";
 200
 201                 $retval = socket_send($comsock, $tosend, strlen($tosend), 0);
 202                 if(!$retval) return false;
 203                 echo "end send message $retval\n";
 204                 // get up to one meg of data - this is bad... i can feel this function
 205                 // hurting alot
 206                 // TODO FIX THIS - its garbage code... im not really sure how to handle this really
 207                 // we need to read back as AS:data:EOD - i think it now does.. i hope, tho we need
 208                 // timeouts now.
 209                 // we wait for an ack
 210                 $size = socket_recv($comsock, $recv, 1024, 0);
 211                 if($recv != "PEN:ACK:INE") {
 212                         echo "invalid response?\n$recv\n";
 213                 } else {
 214                         echo "got ack\n";
 215                 }
 216         }
 217
 218         function receiveMessageInternal($comsock)
 219         {
 220                 echo "begin recieve message\n";
 221                 $recvd = "";
 222                 $continue = true;
 223                 while($continue) {
 224                         $size = socket_recv($comsock, $recvd_a, 1024, 0);
 225
 226                         $recvd .= $recvd_a;
 227                         echo "got $recvd_a so far for $size\n";
 228                         if($size == 0) return false;
 229                         if(preg_match("/.*\:INE$/", $recvd)) {
 230                                 // we have a full string... break out
 231                                 $continue = false;
 232                                 break;
 233                         }
 234                 }
 235
 236
 237                 echo "rec msg next\n";
 238                 // first check we got something that makes sense
 239                 if(preg_match("/^PEN:.*:INE$/", $recvd) < 1) {
 240                         socket_close($comsock);
 241                         echo "Returned data is not in right format\n";
 242                         // we have a problem jim
 243                         return false;
 244                 }
 245                 $msg = "PEN:ACK:INE";
 246                 socket_send($comsock, $msg, strlen($msg), 0);
 247
 248                 echo "got a data packet\n";
 249                 $xps = explode(":", $recvd);
 250
 251                 $component =  base64_decode($xps[1]);
 252
 253                 return $component;
 254         }
 255
 256
 257
 258         private $server;
 259         private $encrypt;
 260         private $semKey;
 261         private $amserver;
 262         private $secure_server;
 263         private $socket;
 264         private $listen_socket;
 265         private $key_priv;
 266         private $key_pub;
 267         private $session_key;
 268
 269 }
 270
 271 /* packets look like
 272  * PEN:base64_enoded data:INE
 273  *
 274  *
 275  */
 276
 277 ?>