diff options
Diffstat (limited to 'vendor/thecodingmachine/safe/generated/sem.php')
| -rw-r--r-- | vendor/thecodingmachine/safe/generated/sem.php | 300 |
1 files changed, 239 insertions, 61 deletions
diff --git a/vendor/thecodingmachine/safe/generated/sem.php b/vendor/thecodingmachine/safe/generated/sem.php index 739e8b389..020212151 100644 --- a/vendor/thecodingmachine/safe/generated/sem.php +++ b/vendor/thecodingmachine/safe/generated/sem.php @@ -5,6 +5,34 @@ namespace Safe; use Safe\Exceptions\SemException; /** + * msg_get_queue returns an id that can be used to + * access the System V message queue with the given + * key. The first call creates the message queue with + * the optional permissions. + * A second call to msg_get_queue for the same + * key will return a different message queue + * identifier, but both identifiers access the same underlying message + * queue. + * + * @param int $key Message queue numeric ID + * @param int $permissions Queue permissions. Default to 0666. If the message queue already + * exists, the permissions will be ignored. + * @return resource Returns SysvMessageQueue instance that can be used to access the System V message queue. + * @throws SemException + * + */ +function msg_get_queue(int $key, int $permissions = 0666) +{ + error_clear_last(); + $result = \msg_get_queue($key, $permissions); + if ($result === false) { + throw SemException::createFromPhpError(); + } + return $result; +} + + +/** * Checks whether the message queue key exists. * * @param int $key Queue key. @@ -24,23 +52,23 @@ function msg_queue_exists(int $key): void /** * msg_receive will receive the first message from the * specified queue of the type specified by - * desiredmsgtype. + * desired_message_type. * - * @param resource $queue Message queue resource handle - * @param int $desiredmsgtype If desiredmsgtype is 0, the message from the front - * of the queue is returned. If desiredmsgtype is + * @param resource $queue The message queue. + * @param int $desired_message_type If desired_message_type is 0, the message from the front + * of the queue is returned. If desired_message_type is * greater than 0, then the first message of that type is returned. - * If desiredmsgtype is less than 0, the first + * If desired_message_type is less than 0, the first * message on the queue with a type less than or equal to the - * absolute value of desiredmsgtype will be read. + * absolute value of desired_message_type will be read. * If no messages match the criteria, your script will wait until a suitable * message arrives on the queue. You can prevent the script from blocking * by specifying MSG_IPC_NOWAIT in the * flags parameter. - * @param int|null $msgtype The type of the message that was received will be stored in this + * @param int|null $received_message_type The type of the message that was received will be stored in this * parameter. - * @param int $maxsize The maximum size of message to be accepted is specified by the - * maxsize; if the message in the queue is larger + * @param int $max_message_size The maximum size of message to be accepted is specified by the + * max_message_size; if the message in the queue is larger * than this size the function will fail (unless you set * flags as described below). * @param mixed $message The received message will be stored in message, @@ -64,7 +92,7 @@ function msg_queue_exists(int $key): void * * MSG_IPC_NOWAIT * If there are no messages of the - * desiredmsgtype, return immediately and do not + * desired_message_type, return immediately and do not * wait. The function will fail and return an integer value * corresponding to MSG_ENOMSG. * @@ -72,30 +100,30 @@ function msg_queue_exists(int $key): void * * MSG_EXCEPT * Using this flag in combination with a - * desiredmsgtype greater than 0 will cause the + * desired_message_type greater than 0 will cause the * function to receive the first message that is not equal to - * desiredmsgtype. + * desired_message_type. * * * MSG_NOERROR * - * If the message is longer than maxsize, + * If the message is longer than max_message_size, * setting this flag will truncate the message to - * maxsize and will not signal an error. + * max_message_size and will not signal an error. * * * * * - * @param int|null $errorcode If the function fails, the optional errorcode + * @param int|null $error_code If the function fails, the optional error_code * will be set to the value of the system errno variable. * @throws SemException * */ -function msg_receive($queue, int $desiredmsgtype, ?int &$msgtype, int $maxsize, &$message, bool $unserialize = true, int $flags = 0, ?int &$errorcode = null): void +function msg_receive($queue, int $desired_message_type, ?int &$received_message_type, int $max_message_size, &$message, bool $unserialize = true, int $flags = 0, ?int &$error_code = null): void { error_clear_last(); - $result = \msg_receive($queue, $desiredmsgtype, $msgtype, $maxsize, $message, $unserialize, $flags, $errorcode); + $result = \msg_receive($queue, $desired_message_type, $received_message_type, $max_message_size, $message, $unserialize, $flags, $error_code); if ($result === false) { throw SemException::createFromPhpError(); } @@ -108,7 +136,7 @@ function msg_receive($queue, int $desiredmsgtype, ?int &$msgtype, int $maxsize, * processes have finished working with the message queue and you need to * release the system resources held by it. * - * @param resource $queue Message queue resource handle + * @param resource $queue The message queue. * @throws SemException * */ @@ -124,15 +152,15 @@ function msg_remove_queue($queue): void /** * msg_send sends a message of type - * msgtype (which MUST be greater than 0) to + * message_type (which MUST be greater than 0) to * the message queue specified by queue. * - * @param resource $queue Message queue resource handle - * @param int $msgtype The type of the message (MUST be greater than 0) + * @param resource $queue The message queue. + * @param int $message_type The type of the message (MUST be greater than 0) * @param mixed $message The body of the message. * * If serialize set to FALSE is supplied, - * MUST be of type: string, integer, float + * MUST be of type: string, int, float * or bool. In other case a warning will be issued. * @param bool $serialize The optional serialize controls how the * message is sent. serialize @@ -148,17 +176,17 @@ function msg_remove_queue($queue): void * optional blocking parameter to FALSE, in which * case msg_send will immediately return FALSE if the * message is too big for the queue, and set the optional - * errorcode to MSG_EAGAIN, + * error_code to MSG_EAGAIN, * indicating that you should try to send your message again a little * later on. - * @param int|null $errorcode If the function fails, the optional errorcode will be set to the value of the system errno variable. + * @param int|null $error_code If the function fails, the optional errorcode will be set to the value of the system errno variable. * @throws SemException * */ -function msg_send($queue, int $msgtype, $message, bool $serialize = true, bool $blocking = true, ?int &$errorcode = null): void +function msg_send($queue, int $message_type, $message, bool $serialize = true, bool $blocking = true, ?int &$error_code = null): void { error_clear_last(); - $result = \msg_send($queue, $msgtype, $message, $serialize, $blocking, $errorcode); + $result = \msg_send($queue, $message_type, $message, $serialize, $blocking, $error_code); if ($result === false) { throw SemException::createFromPhpError(); } @@ -176,7 +204,7 @@ function msg_send($queue, int $msgtype, $message, bool $serialize = true, bool $ * root privileges are required to raise the msg_qbytes values above the * system defined limit. * - * @param resource $queue Message queue resource handle + * @param resource $queue The message queue. * @param array $data You specify the values you require by setting the value of the keys * that you require in the data array. * @throws SemException @@ -193,6 +221,100 @@ function msg_set_queue($queue, array $data): void /** + * msg_stat_queue returns the message queue meta data + * for the message queue specified by the queue. + * This is useful, for example, to determine which process sent the message + * that was just received. + * + * @param resource $queue The message queue. + * @return array On success, the return value is an array whose keys and values have the following + * meanings: + * + * Array structure for msg_stat_queue + * + * + * + * msg_perm.uid + * + * The uid of the owner of the queue. + * + * + * + * msg_perm.gid + * + * The gid of the owner of the queue. + * + * + * + * msg_perm.mode + * + * The file access mode of the queue. + * + * + * + * msg_stime + * + * The time that the last message was sent to the queue. + * + * + * + * msg_rtime + * + * The time that the last message was received from the queue. + * + * + * + * msg_ctime + * + * The time that the queue was last changed. + * + * + * + * msg_qnum + * + * The number of messages waiting to be read from the queue. + * + * + * + * msg_qbytes + * + * The maximum number of bytes allowed in one message queue. On + * Linux, this value may be read and modified via + * /proc/sys/kernel/msgmnb. + * + * + * + * msg_lspid + * + * The pid of the process that sent the last message to the queue. + * + * + * + * msg_lrpid + * + * The pid of the process that received the last message from the queue. + * + * + * + * + * + * + * Returns FALSE on failure. + * @throws SemException + * + */ +function msg_stat_queue($queue): array +{ + error_clear_last(); + $result = \msg_stat_queue($queue); + if ($result === false) { + throw SemException::createFromPhpError(); + } + return $result; +} + + +/** * sem_acquire by default blocks (if necessary) until the * semaphore can be acquired. A process attempting to acquire a semaphore which * it has already acquired will block forever if acquiring the semaphore would @@ -202,19 +324,19 @@ function msg_set_queue($queue, array $data): void * explicitly released will be released automatically and a warning will be * generated. * - * @param resource $sem_identifier sem_identifier is a semaphore resource, + * @param resource $semaphore semaphore is a semaphore * obtained from sem_get. - * @param bool $nowait Specifies if the process shouldn't wait for the semaphore to be acquired. + * @param bool $non_blocking Specifies if the process shouldn't wait for the semaphore to be acquired. * If set to true, the call will return * false immediately if a semaphore cannot be immediately * acquired. * @throws SemException * */ -function sem_acquire($sem_identifier, bool $nowait = false): void +function sem_acquire($semaphore, bool $non_blocking = false): void { error_clear_last(); - $result = \sem_acquire($sem_identifier, $nowait); + $result = \sem_acquire($semaphore, $non_blocking); if ($result === false) { throw SemException::createFromPhpError(); } @@ -235,19 +357,19 @@ function sem_acquire($sem_identifier, bool $nowait = false): void * @param int $key * @param int $max_acquire The number of processes that can acquire the semaphore simultaneously * is set to max_acquire. - * @param int $perm The semaphore permissions. Actually this value is + * @param int $permissions The semaphore permissions. Actually this value is * set only if the process finds it is the only process currently * attached to the semaphore. - * @param int $auto_release Specifies if the semaphore should be automatically released on request + * @param bool $auto_release Specifies if the semaphore should be automatically released on request * shutdown. * @return resource Returns a positive semaphore identifier on success. * @throws SemException * */ -function sem_get(int $key, int $max_acquire = 1, int $perm = 0666, int $auto_release = 1) +function sem_get(int $key, int $max_acquire = 1, int $permissions = 0666, bool $auto_release = true) { error_clear_last(); - $result = \sem_get($key, $max_acquire, $perm, $auto_release); + $result = \sem_get($key, $max_acquire, $permissions, $auto_release); if ($result === false) { throw SemException::createFromPhpError(); } @@ -263,15 +385,15 @@ function sem_get(int $key, int $max_acquire = 1, int $perm = 0666, int $auto_rel * After releasing the semaphore, sem_acquire * may be called to re-acquire it. * - * @param resource $sem_identifier A Semaphore resource handle as returned by + * @param resource $semaphore A Semaphore as returned by * sem_get. * @throws SemException * */ -function sem_release($sem_identifier): void +function sem_release($semaphore): void { error_clear_last(); - $result = \sem_release($sem_identifier); + $result = \sem_release($semaphore); if ($result === false) { throw SemException::createFromPhpError(); } @@ -283,15 +405,74 @@ function sem_release($sem_identifier): void * * After removing the semaphore, it is no longer accessible. * - * @param resource $sem_identifier A semaphore resource identifier as returned + * @param resource $semaphore A semaphore as returned * by sem_get. * @throws SemException * */ -function sem_remove($sem_identifier): void +function sem_remove($semaphore): void +{ + error_clear_last(); + $result = \sem_remove($semaphore); + if ($result === false) { + throw SemException::createFromPhpError(); + } +} + + +/** + * shm_attach returns an id that can be used to access + * the System V shared memory with the given key, the + * first call creates the shared memory segment with + * size and the optional perm-bits + * permissions. + * + * A second call to shm_attach for the same + * key will return a different SysvSharedMemory + * instance, but both instances access the same underlying + * shared memory. size and + * permissions will be ignored. + * + * @param int $key A numeric shared memory segment ID + * @param int $size The memory size. If not provided, default to the + * sysvshm.init_mem in the php.ini, otherwise 10000 + * bytes. + * @param int $permissions The optional permission bits. Default to 0666. + * @return resource Returns a SysvSharedMemory instance on success. + * @throws SemException + * + */ +function shm_attach(int $key, int $size = null, int $permissions = 0666) +{ + error_clear_last(); + if ($permissions !== 0666) { + $result = \shm_attach($key, $size, $permissions); + } elseif ($size !== null) { + $result = \shm_attach($key, $size); + } else { + $result = \shm_attach($key); + } + if ($result === false) { + throw SemException::createFromPhpError(); + } + return $result; +} + + +/** + * shm_detach disconnects from the shared memory given + * by the shm created by + * shm_attach. Remember, that shared memory still exist + * in the Unix system and the data is still present. + * + * @param resource $shm A shared memory segment obtained from shm_attach. + * @throws SemException + * + */ +function shm_detach($shm): void { error_clear_last(); - $result = \sem_remove($sem_identifier); + $result = \shm_detach($shm); if ($result === false) { throw SemException::createFromPhpError(); } @@ -300,28 +481,27 @@ function sem_remove($sem_identifier): void /** * shm_put_var inserts or updates the - * variable with the given - * variable_key. + * value with the given + * key. * * Warnings (E_WARNING level) will be issued if - * shm_identifier is not a valid SysV shared memory + * shm is not a valid SysV shared memory * index or if there was not enough shared memory remaining to complete your * request. * - * @param resource $shm_identifier A shared memory resource handle as returned by - * shm_attach - * @param int $variable_key The variable key. - * @param mixed $variable The variable. All variable types + * @param resource $shm A shared memory segment obtained from shm_attach. + * @param int $key The variable key. + * @param mixed $value The variable. All variable types * that serialize supports may be used: generally * this means all types except for resources and some internal objects * that cannot be serialized. * @throws SemException * */ -function shm_put_var($shm_identifier, int $variable_key, $variable): void +function shm_put_var($shm, int $key, $value): void { error_clear_last(); - $result = \shm_put_var($shm_identifier, $variable_key, $variable); + $result = \shm_put_var($shm, $key, $value); if ($result === false) { throw SemException::createFromPhpError(); } @@ -329,19 +509,18 @@ function shm_put_var($shm_identifier, int $variable_key, $variable): void /** - * Removes a variable with a given variable_key + * Removes a variable with a given key * and frees the occupied memory. * - * @param resource $shm_identifier The shared memory identifier as returned by - * shm_attach - * @param int $variable_key The variable key. + * @param resource $shm A shared memory segment obtained from shm_attach. + * @param int $key The variable key. * @throws SemException * */ -function shm_remove_var($shm_identifier, int $variable_key): void +function shm_remove_var($shm, int $key): void { error_clear_last(); - $result = \shm_remove_var($shm_identifier, $variable_key); + $result = \shm_remove_var($shm, $key); if ($result === false) { throw SemException::createFromPhpError(); } @@ -350,17 +529,16 @@ function shm_remove_var($shm_identifier, int $variable_key): void /** * shm_remove removes the shared memory - * shm_identifier. All data will be destroyed. + * shm. All data will be destroyed. * - * @param resource $shm_identifier The shared memory identifier as returned by - * shm_attach + * @param resource $shm A shared memory segment obtained from shm_attach. * @throws SemException * */ -function shm_remove($shm_identifier): void +function shm_remove($shm): void { error_clear_last(); - $result = \shm_remove($shm_identifier); + $result = \shm_remove($shm); if ($result === false) { throw SemException::createFromPhpError(); } |