function shm_remove_var($id, $key)
{
global $_shm_size;
if (($dat = @shmop_read($id, 0, 4)) === false) {
$dat = array();
} else {
$len = unpack('L', $dat);
$len = array_shift($len);
$dat = unserialize(shmop_read($id, 4, $len));
}
if (isset($dat[$key])) {
unset($dat[$key]);
} else {
return false;
}
$dat = serialize($dat);
$l = strlen($dat);
if ($l + 4 > $_shm_size) {
return false;
}
$dat = pack('L', strlen($dat)) . $dat;
if (@shmop_write($id, $dat, 0) !== false) {
return true;
}
return false;
}
function shm_put($shm, $data)
{
if (!$shm) {
return false;
}
return shmop_write($shm, serialize($data), 0);
}
/**
* Writes a message to the shared memory.
*
* @param mixed $message The message to send
* @param integer $signal The signal to send afterward
* @param integer $pause The number of microseconds to pause after signalling
*/
public function send($message, $signal = null, $pause = 500)
{
$messageArray = array();
if (($shmId = @shmop_open($this->pid, 'a', 0, 0)) > 0) {
// Read any existing messages in shared memory
$readMessage = shmop_read($shmId, 0, shmop_size($shmId));
$messageArray[] = unserialize($readMessage);
shmop_delete($shmId);
shmop_close($shmId);
}
// Add the current message to the end of the array, and serialize it
$messageArray[] = $message;
$serializedMessage = serialize($messageArray);
// Write new serialized message to shared memory
$shmId = shmop_open($this->pid, 'c', 0644, strlen($serializedMessage));
if (!$shmId) {
throw new ProcessControlException(sprintf('Not able to create shared memory segment for PID: %s', $this->pid));
} else {
if (shmop_write($shmId, $serializedMessage, 0) !== strlen($serializedMessage)) {
throw new ProcessControlException(sprintf('Not able to write message to shared memory segment for segment ID: %s', $shmId));
}
}
if (false === $signal) {
return;
}
$this->signal($signal ?: $this->signal);
usleep($pause);
}
public function write($data, $from = 0)
{
$count = false;
if ($this->status == self::STATUS_OPENED) {
$count = shmop_write($this->shmId, $data, $from);
}
return $count;
}
public function save($shmKey, $appVars)
{
$memBlobkId = @shmop_open($shmKey, "w", 0644, 1024);
$result = shmop_write($memBlobkId, serialize($appVars), 0);
shmop_close($memBlobkId);
return $result;
}
/**
* Run some code in a thread.
*
* @param callable $func The function to execute
* @param array|mixed $args The arguments (or a single argument) to pass to the function
*
* @return int The pid of the thread created to execute this code
*/
public function call(callable $func, $args = null)
{
$pid = pcntl_fork();
if ($pid == -1) {
throw new \Exception("Failed to fork");
}
# If this is the child process, then run the requested function
if (!$pid) {
try {
if ($args === null) {
$func();
} else {
call_user_func_array($func, $args);
}
} catch (\Exception $e) {
$memory = shmop_open($this->memoryKey, "c", 0644, static::SHARED_MEMORY_LIMIT);
$errors = shmop_read($memory, 0, static::SHARED_MEMORY_LIMIT);
$errors = trim($errors);
if ($errors) {
$errors .= "\n";
}
$errors .= "Exception: " . $e->getMessage() . " (" . $e->getFile() . ":" . $e->getLine() . ")";
shmop_write($memory, $errors, 0);
shmop_close($memory);
exit(1);
}
# Then we must exit or else we will end up the child process running the parent processes code
die;
}
$this->threads[$pid] = $pid;
return $pid;
}
private function Write($data)
{
$tmp = serialize($data);
$this->ShmIsClean = false;
//echo "writing $tmp<br/>";
return shmop_write($this->mShmId, $tmp, 0) == strlen($tmp) ? true : false;
}
function session_value($name, $index)
{
global $shm_key, $shm_var, $sem_id;
switch ($index) {
case 'config':
$shm_size = 859;
break;
case 'ipdata':
$shm_size = 30050;
break;
default:
$shm_size = 0;
}
sem_acquire($sem_id['shlock']);
$shm_id = shmop_open($shm_key[$index], 'c', 0644, $shm_size);
if ($name == 'update') {
$shm_data = serialize($shm_var[$index]);
shmop_write($shm_id, str_pad($shm_data, $shm_size, "", STR_PAD_RIGHT), 0);
} else {
$shm_data = shmop_read($shm_id, 0, $shm_size);
$shm_var[$index] = @unserialize($shm_data);
}
shmop_close($shm_id);
sem_release($sem_id['shlock']);
}
/**
* 写入一个值到某shmkey对应的内存块
*
* @param int $shmKey 内存块标示key
* @param string $value 值（必须是字符串，在外部序列化或者encode）
*/
private function writeValueToSHM($shmKey, $value)
{
$data = $value;
$size = mb_strlen($data, 'UTF-8');
$shmId = shmop_open($shmKey, 'c', 0644, $size);
shmop_write($shmId, $data, 0);
shmop_close($shmId);
}
/**
* Unlock process
*
* @return Mage_Index_Model_Process
*/
public function unlock()
{
$shmId = shmop_open($this->getIndexerId(), 'w', self::PERM, self::LEN);
shmop_write($shmId, str_repeat('0', $this->_getMicrotimeLen()), 0);
// cannot delete because sometimes we're not the owner. so overwrite
shmop_close($shmId);
$this->_isLocked = false;
}
/**
* Add an exception the shared memory.
*
* @param \Throwable $exception The exception instance to add
*
* @return void
*/
public function addException(\Throwable $exception)
{
$memory = shmop_open($this->key, "c", 0644, self::LIMIT);
$exceptions = $this->unserialize($memory);
$exceptions[] = get_class($exception) . ": " . $exception->getMessage() . " (" . $exception->getFile() . ":" . $exception->getLine() . ")";
$data = serialize($exceptions);
shmop_write($memory, $data, 0);
shmop_close($memory);
}
/**
* Mark a shared memory block for deletion.
*
* @return bool
*/
public function delete()
{
/*
* Bug fix
* @link https://bugs.php.net/bug.php?id=71921
*/
shmop_write($this->shmid, str_pad('', shmop_size($this->shmid), ' '), 0);
return shmop_delete($this->shmid);
}
function MonWrite($data)
{
// Escritura de una cadena de texto de prueba en la memoria compartida
$shm_bytes_written = shmop_write($this->{$shm_id}, $data, 0);
if ($shm_bytes_written != strlen($data)) {
debug("No se pudieron escribir todos los datos indicados\n", "red");
} else {
debug("Saved {$data}\n", "magenta");
}
}
function set($key, $val, $ttl = 600)
{
if (function_exists('gzcompress')) {
$val = gzcompress($val, 3);
}
$this->shmop_key = ftok($this->pre . $key);
$this->shmop_id = shmop_open($this->shmop_key, 'c', 0644, strlen($val));
$result = shmop_write($this->shmop_id, $val, 0);
shmop_close($this->shmop_id);
return $result;
}
public function write($id, $size, $data)
{
$shm = $this->open($id, $size);
$written = shmop_write($shm, $data, 0);
$this->close($shm);
if ($written != strlen($data)) {
trigger_error('pc_Shm: could not write entire length of data', E_USER_ERROR);
return false;
}
return true;
}
public function enQueue($value)
{
if ($this->ptrInc($this->rear) == $this->front) {
// 队满
return false;
}
$data = $this->encode($value);
shmop_write($this->shmId, $data, $this->rear);
$this->rear = $this->ptrInc($this->rear);
return true;
}
protected function tearDown()
{
if ($shmid = @shmop_open(self::SHMOP_ID, 'w', 0644, 0)) {
/*
* Fill memory block for fix bug
* @link https://bugs.php.net/bug.php?id=71921
*/
shmop_write($shmid, str_pad('', strlen(self::WORD), ' '), 0);
shmop_delete($shmid);
shmop_close($shmid);
}
}
public function __destruct()
{
if ($this->changed) {
$serialized = serialize($this->data);
if (strlen($serialized) > shmop_size($this->res)) {
shmop_delete($this->res);
$this->res = shmop_open($id, 'c', 0644, ceil(strlen($serialized) * 1.25));
}
shmop_write($this->res, $serialized, 0);
}
shmop_close($this->res);
}
public function writeShared($data_arr)
{
$null_fill = str_repeat(str_repeat(' ', 10), $this->size / 10);
shmop_write($this->shm_id, $null_fill, 0);
$data = serialize($data_arr);
if (strlen($data) > $this->size) {
return false;
}
shmop_write($this->shm_id, $data, 0);
sem_release($this->sem_id);
return true;
}
private function _write(&$val, &$lh)
{
$id = shmop_open($this->handler, 'c', 0600, $this->options['size']);
if ($id) {
$ret = shmop_write($id, $val, 0) == strlen($val);
shmop_close($id);
$this->_unlock($lh);
return $ret;
}
$this->_unlock($lh);
return false;
}
function execute()
{
set_error_handler('fragtable_error_handler');
define('FRAGTABLE_ROOT', dirname(__FILE__));
$HTTP_HOST = isset($_SERVER['HTTP_HOST']) ? $_SERVER['HTTP_HOST'] : 'NULL';
$HTTP_USER_AGENT = isset($_SERVER['HTTP_USER_AGENT']) ? $_SERVER['HTTP_USER_AGENT'] : 'NULL';
if (!isset($_SERVER['REQUEST_URI'])) {
trigger_error("'REQUEST_URI' not found", E_USER_WARNING);
}
$salt = $HTTP_USER_AGENT . $_SERVER['REQUEST_URI'];
$hashi = hexdec(substr(hash('crc32b', $salt), 0, 2));
$subject = "[{$HTTP_HOST}] DDoS WARNING!!";
$accucnt = 0;
$logfile = FRAGTABLE_ROOT . '/secure.log';
$shm_key['data'] = ftok(__FILE__, 't');
$shm_key['lock'] = ftok(__FILE__, 'u');
$sem_id = sem_get($shm_key['lock']);
$shm_size = 9626;
sem_acquire($sem_id);
$shm_id = shmop_open($shm_key['data'], 'c', 0644, $shm_size);
$shm_data = shmop_read($shm_id, 0, $shm_size);
$fragtable = @unserialize($shm_data);
if (!$fragtable) {
$fragtable = array();
}
$nowtime = time();
if (isset($fragtable[$hashi]) && $nowtime < $fragtable[$hashi][0] + self::$intervsl) {
$accucnt = $fragtable[$hashi][1] < 99 ? $fragtable[$hashi][1] + 1 : $fragtable[$hashi][1];
$acctime = $fragtable[$hashi][0];
} else {
$accucnt = 1;
$acctime = $nowtime;
}
$fragtable[$hashi] = array($acctime, $accucnt);
$shm_data = serialize($fragtable);
shmop_write($shm_id, str_pad($shm_data, $shm_size, "", STR_PAD_RIGHT), 0);
shmop_close($shm_id);
sem_release($sem_id);
$fragtable = $shm_data = NULL;
if ($accucnt > self::$threshold) {
if (!file_exists($logfile) || filesize($logfile) < 10 * 1024 * 1024) {
$message = sprintf("%s | %d | %d | %s | %s | %s\n", gmdate('Y-m-d H:i:s', $nowtime + self::$timezone * 3600), $acctime, $hashi, str_pad($_SERVER["REMOTE_ADDR"], 15, ' ', STR_PAD_RIGHT), "{$_SERVER['REQUEST_METHOD']} {$_SERVER['REQUEST_URI']} {$_SERVER['SERVER_PROTOCOL']}", $HTTP_USER_AGENT);
if (!file_exists($logfile) || $nowtime > filemtime($logfile) + 3600) {
@mail(self::$mailto, $subject, $message);
}
file_put_contents($logfile, $message, FILE_APPEND | LOCK_EX);
}
header('HTTP/1.1 503 Service Temporarily Unavailable');
die('<h1>Service Temporarily Unavailable</h1>');
}
restore_error_handler();
}
private function _setData($data)
{
// serialize data before storing to shared memory
$data = serialize($data);
// get new data length
$dataLength = mb_strlen($data, 'UTF8');
// storee new data length
$this->_setDataLength($dataLength);
// store new data
$dataShm = shmop_open($this->_dataShmKey, 'c', 0644, $dataLength);
shmop_write($dataShm, $data, 0);
shmop_close($dataShm);
}
function stream_write($data)
{
$p = $this->path;
$fp = fopen($p, 'w');
fwrite($fp, $data);
fclose($fp);
$this->id = ftok($this->path, 'M');
if ($t = @shmop_open($this->id, 'a', 0, 0)) {
shmop_delete($t);
}
$t = shmop_open($this->id, 'c', 0755, strlen($data));
shmop_write($t, $data, 0);
}
function dmx_write_shared_memory($shm_id, $di, $do1, $do2)
{
global $debug;
if ($di) {
shmop_write($shm_id, $di, 0);
}
if ($do1) {
shmop_write($shm_id, $do1, 256);
}
if ($do2) {
shmop_write($shm_id, $do2, 512);
}
return 1;
}
public function writemem($shmkey, $fdata)
{
if ($this->MEMCOMPRESS && function_exists('gzcompress')) {
$fdata = gzcompress($fdata, $this->MEMCOMPRESSLVL);
}
$fsize = strlen($fdata);
$shm_bytes_written = shmop_write($shmkey, $fdata, 0);
$this->updatestats($shm_bytes_written, "add");
if ($shm_bytes_written != $fsize) {
return false;
} else {
return $shm_bytes_written;
}
}
public function put($data)
{
$size = self::generateSize($data);
$exists = $this->exists($this->id);
if ($exists) {
shmop_delete($this->shmId);
shmop_close($this->shmId);
$this->shmId = shmop_open($this->id, "c", $this->perms, $size);
shmop_write($this->shmId, serialize($data), 0);
} else {
$this->shmId = shmop_open($this->id, "c", $this->perms, $size);
shmop_write($this->shmId, serialize($data), 0);
}
}
/**
* @param string $data
* @return boolean
*/
public function write($data)
{
$data = (string) $data;
if ($this->exists($this->shmKey)) {
$this->delete();
}
$size = mb_strlen($data, 'UTF-8');
$shmId = shmop_open($this->shmKey, 'c', 666, $size);
if (!$shmId) {
return false;
}
shmop_write($shmId, $data, 0);
shmop_close($shmId);
return true;
}
static function clear($changed_tables)
{
$cache_data = shmop_read(self::$shm, self::$_id, self::$_size);
$cache_data = @unserialize($cache_data);
foreach ($changed_tables as $table => $flag) {
if (!empty(self::$_cache_handlers[$table])) {
foreach (self::$_cache_handlers[$table] as $cache_name => $_d) {
unset($cache_data[$cache_name]);
}
}
}
$cache_data['cache_handlers'] = self::$_cache_handlers;
shmop_write(self::$shm, serialize($cache_data), self::$_id);
return true;
}
/**
* write data
*
* @param mix $data
* @return void
* @throws RuntimeException
*/
public function write($data)
{
$serializedData = serialize(array('pid' => $this->pid, 'data' => $data));
$s = shmop_open($this->genKey(), 'n', 0666, strlen($serializedData));
if ($s === false) {
throw new RuntimeException('could not open shared memory');
}
$writtenSize = shmop_write($s, $serializedData, 0);
if ($writtenSize === false) {
shmop_delete($s);
shmop_close($s);
throw new RuntimeException('could not write the data to shared memory');
}
shmop_close($s);
}
private function write($data = null)
{
if (is_null($data)) {
$db = STORAGE_PATH . DS . 'memory' . sha1($this->ns . $this->entity) . '.db';
$data = $this->data();
File::delete($db);
File::put($db, $data);
}
shmop_delete($this->db);
shmop_close($this->db);
$size = $this->size > strlen($data) ? $this->size : strlen($data);
$this->size = $size;
$this->db = shmop_open($this->key, 'c', 0755, $size);
return shmop_write($this->db, $data, 0);
}
