[prev in list] [next in list] [prev in thread] [next in thread]
List: pecl-cvs
Subject: [PECL-CVS] cvs: pecl /win32scheduler CREDITS config.w32 php_win32scheduler.h task.php win32scheduler
From: "Wez Furlong" <wez () php ! net>
Date: 2005-01-30 18:21:20
Message-ID: cvswez1107109280 () cvsserver
[Download RAW message or body]
wez Sun Jan 30 13:21:20 2005 EDT
Added files:
/pecl/win32scheduler CREDITS config.w32 php_win32scheduler.h
task.php win32scheduler.c
Log:
Add new win32scheduler extension for manipulating scheduled tasks on
windows systems.
["wez-20050130132120.txt" (text/plain)]
http://cvs.php.net/co.php/pecl/win32scheduler/config.w32?r=1.1&p=1
Index: pecl/win32scheduler/config.w32
+++ pecl/win32scheduler/config.w32
// $Id: config.w32,v 1.1 2005/01/30 18:21:19 wez Exp $
// vim:ft=javascript
ARG_ENABLE("win32scheduler", "Task Scheduler API", "no");
if (PHP_WIN32SCHEDULER != "no") {
EXTENSION("win32scheduler", "win32scheduler.c");
}
http://cvs.php.net/co.php/pecl/win32scheduler/php_win32scheduler.h?r=1.1&p=1
Index: pecl/win32scheduler/php_win32scheduler.h
+++ pecl/win32scheduler/php_win32scheduler.h
/*
+----------------------------------------------------------------------+
| PHP Version 5 |
+----------------------------------------------------------------------+
| Copyright (c) 1997-2005 The PHP Group |
+----------------------------------------------------------------------+
| This source file is subject to version 3.0 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_0.txt. |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Wez Furlong <wez@php.net> |
+----------------------------------------------------------------------+
*/
/* $Id: php_win32scheduler.h,v 1.1 2005/01/30 18:21:19 wez Exp $ */
#ifndef PHP_WIN32SCHEDULER_H
#define PHP_WIN32SCHEDULER_H
extern zend_module_entry win32scheduler_module_entry;
#define phpext_win32scheduler_ptr &win32scheduler_module_entry
#ifndef PHP_WIN32
# error This extension is for win32 only
#endif
#endif
http://cvs.php.net/co.php/pecl/win32scheduler/task.php?r=1.1&p=1
Index: pecl/win32scheduler/task.php
+++ pecl/win32scheduler/task.php
<?php
foreach(win32_scheduler_enum_tasks() as $name) {
echo "$name\n";
debug_zval_dump(win32_scheduler_get_task_info($name));
}
$foo = array(
'ApplicationName' => 'notepad.exe',
'MaxRunTime' => 3600,
'Priority' => WIN32_SCHEDULER_NORMAL_PRIORITY,
'RunAs' => 'username',
'Password' => 'secret',
'Comment' => 'Hello!',
'Creator' => 'wez',
'Flags' => WIN32_SCHEDULER_FLAG_RUN_ONLY_IF_LOGGED_ON,
'IdleWaitMinutes' => 1,
'IdleWaitDeadlineMinutes' => 5,
'Triggers' => array(
array(
'TriggerType' => WIN32_SCHEDULER_TRIGGER_ON_IDLE,
)
)
);
//$x = win32_scheduler_set_task_info('test.job', $foo, true);
//debug_zval_dump($x);
?>
http://cvs.php.net/co.php/pecl/win32scheduler/win32scheduler.c?r=1.1&p=1
Index: pecl/win32scheduler/win32scheduler.c
+++ pecl/win32scheduler/win32scheduler.c
/*
+----------------------------------------------------------------------+
| PHP Version 5 |
+----------------------------------------------------------------------+
| Copyright (c) 1997-2005 The PHP Group |
+----------------------------------------------------------------------+
| This source file is subject to version 3.0 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_0.txt. |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Wez Furlong <wez@php.net> |
+----------------------------------------------------------------------+
*/
/* $Id: win32scheduler.c,v 1.1 2005/01/30 18:21:19 wez Exp $ */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "php.h"
#include "php_ini.h"
#include "ext/standard/info.h"
#include "php_win32scheduler.h"
#define COBJMACROS
#include <initguid.h>
#include <mstask.h>
#include <msterr.h>
static ITaskScheduler *get_sched(char *machine, int machinelen TSRMLS_DC)
{
LPWSTR wname;
ITaskScheduler *ITS;
HRESULT hr;
hr = CoCreateInstance(&CLSID_CTaskScheduler, NULL, CLSCTX_INPROC_SERVER, \
&IID_ITaskScheduler, (void**)&ITS); if (FAILED(hr)) {
return NULL;
}
if (machine) {
wname = php_com_string_to_olestring(machine, machinelen, CP_ACP TSRMLS_CC);
if (wname) {
hr = ITaskScheduler_SetTargetComputer(ITS, wname);
efree(wname);
if (FAILED(hr)) {
ITaskScheduler_Release(ITS);
return NULL;
}
}
}
return ITS;
}
/* {{{ proto array win32_scheduler_enum_tasks([string machine])
Returns an array of task names */
static PHP_FUNCTION(win32_scheduler_enum_tasks)
{
ITaskScheduler *ITS;
IEnumWorkItems *IEWI;
LPWSTR *names;
DWORD got;
HRESULT hr;
char *machine = NULL;
int machinelen;
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!", &machine, \
&machinelen)) { RETURN_FALSE;
}
ITS = get_sched(machine, machinelen TSRMLS_CC);
if (ITS == NULL) {
RETURN_FALSE;
}
hr = ITaskScheduler_Enum(ITS, &IEWI);
if (FAILED(hr)) {
ITaskScheduler_Release(ITS);
RETURN_FALSE;
}
array_init(return_value);
got = 0;
while (SUCCEEDED(IEnumWorkItems_Next(IEWI, 10, &names, &got)) && got) {
while (got) {
uint len;
char *name = php_com_olestring_to_string(names[--got], &len, CP_ACP TSRMLS_CC);
if (name) {
add_next_index_stringl(return_value, name, len, 0);
}
CoTaskMemFree(names[got]);
}
CoTaskMemFree(names);
}
IEnumWorkItems_Release(IEWI);
ITaskScheduler_Release(ITS);
}
/* }}} */
/* {{{ proto array win32_scheduler_delete_task(string name [, string machine])
Deletes a named task */
static PHP_FUNCTION(win32_scheduler_delete_task)
{
LPWSTR wname;
ITaskScheduler *ITS;
ITask *T;
HRESULT hr;
char *name, *machine = NULL;
int namelen, machinelen;
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s!", &name, \
&namelen, &machine, &machinelen)) { RETURN_FALSE;
}
ITS = get_sched(machine, machinelen TSRMLS_CC);
if (!ITS) {
RETURN_FALSE;
}
wname = php_com_string_to_olestring(name, namelen, CP_ACP TSRMLS_CC);
if (wname) {
hr = ITaskScheduler_Delete(ITS, wname);
efree(wname);
}
ITaskScheduler_Release(ITS);
if (FAILED(hr)) {
RETURN_FALSE;
}
RETURN_TRUE;
}
/* }}} */
static ITask *get_task(char *name, int namelen, int isnew, char *machine, int \
machinelen TSRMLS_DC) {
LPWSTR wname;
ITaskScheduler *ITS;
ITask *T;
HRESULT hr;
ITS = get_sched(machine, machinelen TSRMLS_CC);
if (ITS == NULL) {
return NULL;
}
wname = php_com_string_to_olestring(name, namelen, CP_ACP TSRMLS_CC);
if (wname) {
if (isnew) {
hr = ITaskScheduler_NewWorkItem(ITS, wname, &CLSID_CTask, &IID_ITask, \
(IUnknown**)&T); } else {
hr = ITaskScheduler_Activate(ITS, wname, &IID_ITask, (IUnknown**)&T);
}
if (FAILED(hr)) {
T = NULL;
}
efree(wname);
} else {
T = NULL;
}
ITaskScheduler_Release(ITS);
return T;
}
/* {{{ proto bool win32_scheduler_run(string taskname [, bool terminate [, string \
machine ]]) Runs the specified task; returns true if it could be started, false \
otherwise. Does not wait for task to complete. If terminate is true, task is \
terminated instead of run. */ static PHP_FUNCTION(win32_scheduler_run)
{
char *name, *machine = NULL;
int namelen, machinelen;
zend_bool b = 0;
ITask *T;
HRESULT hr;
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|bs!", &name, \
&namelen, &b, &machine, &machinelen)) { RETURN_FALSE;
}
T = get_task(name, namelen, 0, machine, machinelen TSRMLS_CC);
if (!T) {
RETURN_FALSE;
}
if (b) {
hr = ITask_Terminate(T);
} else {
hr = ITask_Run(T);
}
ITask_Release(T);
if (FAILED(hr)) {
RETURN_FALSE;
}
RETURN_TRUE;
}
/* }}} */
/* {{{ proto array win32_scheduler_get_task_info(string taskname [, string machine])
Fetches info for the named task */
static PHP_FUNCTION(win32_scheduler_get_task_info)
{
char *name, *machine = NULL;
int namelen, machinelen;
ITask *T;
HRESULT hr;
LPWSTR wstr;
uint len;
DWORD dw, trigger_count;
WORD w, w2;
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s!", &name, \
&namelen, &machine, &machinelen)) { RETURN_FALSE;
}
T = get_task(name, namelen, 0, machine, machinelen TSRMLS_CC);
if (!T) {
RETURN_FALSE;
}
array_init(return_value);
/* ITask */
if (SUCCEEDED(ITask_GetApplicationName(T, &wstr))) {
name = php_com_olestring_to_string(wstr, &len, CP_ACP TSRMLS_CC);
if (name) {
add_assoc_stringl(return_value, "ApplicationName", name, len, 0);
}
CoTaskMemFree(wstr);
}
if (SUCCEEDED(ITask_GetMaxRunTime(T, &dw))) {
add_assoc_long(return_value, "MaxRunTime", (long)dw);
}
if (SUCCEEDED(ITask_GetParameters(T, &wstr))) {
name = php_com_olestring_to_string(wstr, &len, CP_ACP TSRMLS_CC);
if (name) {
add_assoc_stringl(return_value, "Parameters", name, len, 0);
}
CoTaskMemFree(wstr);
}
if (SUCCEEDED(ITask_GetPriority(T, &dw))) {
add_assoc_long(return_value, "Priority", (long)dw);
}
if (SUCCEEDED(ITask_GetWorkingDirectory(T, &wstr))) {
name = php_com_olestring_to_string(wstr, &len, CP_ACP TSRMLS_CC);
if (name) {
add_assoc_stringl(return_value, "WorkingDirectory", name, len, 0);
}
CoTaskMemFree(wstr);
}
/* IScheduledWorkItem */
if (SUCCEEDED(ITask_GetAccountInformation(T, &wstr))) {
name = php_com_olestring_to_string(wstr, &len, CP_ACP TSRMLS_CC);
if (name) {
add_assoc_stringl(return_value, "RunAs", name, len, 0);
}
CoTaskMemFree(wstr);
}
if (SUCCEEDED(ITask_GetComment(T, &wstr))) {
name = php_com_olestring_to_string(wstr, &len, CP_ACP TSRMLS_CC);
if (name) {
add_assoc_stringl(return_value, "Comment", name, len, 0);
}
CoTaskMemFree(wstr);
}
if (SUCCEEDED(ITask_GetCreator(T, &wstr))) {
name = php_com_olestring_to_string(wstr, &len, CP_ACP TSRMLS_CC);
if (name) {
add_assoc_stringl(return_value, "Creator", name, len, 0);
}
CoTaskMemFree(wstr);
}
if (SUCCEEDED(ITask_GetErrorRetryCount(T, &w))) {
add_assoc_long(return_value, "ErrorRetryCount", (long)w);
}
if (SUCCEEDED(ITask_GetErrorRetryInterval(T, &w))) {
add_assoc_long(return_value, "ErrorRetryInterval", (long)w);
}
if (SUCCEEDED(ITask_GetExitCode(T, &dw))) {
add_assoc_long(return_value, "ExitCode", (long)dw);
}
if (SUCCEEDED(ITask_GetFlags(T, &dw))) {
add_assoc_long(return_value, "Flags", (long)dw);
}
if (SUCCEEDED(ITask_GetIdleWait(T, &w, &w2))) {
add_assoc_long(return_value, "IdleWaitMinutes", (long)w);
add_assoc_long(return_value, "IdleDeadlineMinutes", (long)w2);
}
if (SUCCEEDED(ITask_GetStatus(T, &dw))) {
add_assoc_long(return_value, "Status", (long)dw);
}
/* TODO: times... */
if (SUCCEEDED(ITask_GetTriggerCount(T, &trigger_count))) {
zval *trig;
zval *triggers;
int i;
ITaskTrigger *ITT;
TASK_TRIGGER trigdat;
MAKE_STD_ZVAL(triggers);
array_init(triggers);
for (i = 0; i < trigger_count; i++) {
if (FAILED(ITask_GetTrigger(T, i, &ITT))) {
break;
}
MAKE_STD_ZVAL(trig);
array_init(trig);
ITaskTrigger_GetTrigger(ITT, &trigdat);
add_assoc_long(trig, "BeginYear", trigdat.wBeginYear);
add_assoc_long(trig, "BeginMonth", trigdat.wBeginMonth);
add_assoc_long(trig, "BeginDay", trigdat.wBeginDay);
add_assoc_long(trig, "EndYear", trigdat.wEndYear);
add_assoc_long(trig, "EndMonth", trigdat.wEndMonth);
add_assoc_long(trig, "EndDay", trigdat.wEndDay);
add_assoc_long(trig, "StartHour", trigdat.wStartHour);
add_assoc_long(trig, "StartMinute", trigdat.wStartMinute);
add_assoc_long(trig, "MinutesDuration", trigdat.MinutesDuration);
add_assoc_long(trig, "MinutesInterval", trigdat.MinutesInterval);
add_assoc_long(trig, "Flags", trigdat.rgFlags);
add_assoc_long(trig, "TriggerType", trigdat.TriggerType);
add_assoc_long(trig, "RandomMinutesInterval", trigdat.wRandomMinutesInterval);
switch (trigdat.TriggerType) {
case TASK_TIME_TRIGGER_DAILY:
add_assoc_long(trig, "Daily.DaysInterval", trigdat.Type.Daily.DaysInterval);
break;
case TASK_TIME_TRIGGER_WEEKLY:
add_assoc_long(trig, "Weekly.WeeksInterval", trigdat.Type.Weekly.WeeksInterval);
add_assoc_long(trig, "Weekly.DaysOfTheWeek", \
trigdat.Type.Weekly.rgfDaysOfTheWeek); break;
case TASK_TIME_TRIGGER_MONTHLYDATE:
add_assoc_long(trig, "MonthlyDate.Days", trigdat.Type.MonthlyDate.rgfDays);
add_assoc_long(trig, "MonthlyDate.Months", trigdat.Type.MonthlyDate.rgfMonths);
break;
case TASK_TIME_TRIGGER_MONTHLYDOW:
add_assoc_long(trig, "MonthlyDOW.WhichWeek", \
trigdat.Type.MonthlyDOW.wWhichWeek);
add_assoc_long(trig, "MonthlyDOW.DaysOfTheWeek", \
trigdat.Type.MonthlyDOW.rgfDaysOfTheWeek);
add_assoc_long(trig, "MonthlyDOW.Months", trigdat.Type.MonthlyDOW.rgfMonths);
break;
}
if (SUCCEEDED(ITaskTrigger_GetTriggerString(ITT, &wstr))) {
name = php_com_olestring_to_string(wstr, &len, CP_ACP TSRMLS_CC);
if (name) {
add_assoc_stringl(trig, "TriggerString", name, len, 0);
}
CoTaskMemFree(wstr);
}
add_next_index_zval(triggers, trig);
}
add_assoc_zval(return_value, "Triggers", triggers);
}
ITask_Release(T);
}
/* }}} */
/* {{{ proto bool win32_scheduler_set_task_info(string taskname, array info [, bool \
new [, string machine]]) Updates the info for an existing named task, or if the \
"new" is true, creates a new task */ static \
PHP_FUNCTION(win32_scheduler_set_task_info) {
char *name, *machine = NULL;
int namelen, machinelen;
ITask *T;
HRESULT hr;
LPWSTR wstr;
uint len;
DWORD dw, trigger_count;
WORD w, w2;
zval *details, **tmp, **triggers, **trigger;
zend_bool isnew = 0;
IPersistFile *IPF;
ITaskTrigger *ITT = NULL;
int error_line = 0;
#define ERROR_OUT_IF_FAILED() if (FAILED(hr)) { error_line = __LINE__; goto out; }
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sa|bs!",
&name, &namelen, &details, &isnew, &machine, &machinelen)) {
RETURN_FALSE;
}
T = get_task(name, namelen, isnew, machine, machinelen TSRMLS_CC);
if (!T) {
RETURN_FALSE;
}
#define STR_DETAIL(name, setter) \
if (SUCCESS == zend_hash_find(Z_ARRVAL_P(details), name, sizeof(name), \
(void**)&tmp)) { \ convert_to_string_ex(tmp); \
wstr = php_com_string_to_olestring(Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp), CP_ACP \
TSRMLS_CC); \ if (wstr) { \
hr = setter(T, wstr); \
efree(wstr); \
ERROR_OUT_IF_FAILED(); \
} \
}
STR_DETAIL("ApplicationName", ITask_SetApplicationName);
STR_DETAIL("Parameters", ITask_SetParameters);
STR_DETAIL("WorkingDirectory", ITask_SetWorkingDirectory);
STR_DETAIL("Comment", ITask_SetComment);
STR_DETAIL("Creator", ITask_SetCreator);
if (SUCCESS == zend_hash_find(Z_ARRVAL_P(details), "RunAs", sizeof("RunAs"), \
(void**)&tmp)) { LPWSTR username, password;
convert_to_string_ex(tmp);
username = php_com_string_to_olestring(Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp), CP_ACP \
TSRMLS_CC); if (username) {
if (SUCCESS == zend_hash_find(Z_ARRVAL_P(details), "Password", sizeof("Password"), \
(void**)&tmp)) { convert_to_string_ex(tmp);
password = php_com_string_to_olestring(Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp), CP_ACP \
TSRMLS_CC);
if (password) {
hr = ITask_SetAccountInformation(T, username, password);
efree(password);
}
} else {
hr = E_INVALIDARG;
}
efree(username);
} else {
hr = E_ERROR;
}
ERROR_OUT_IF_FAILED();
}
#define DWORD_DETAIL(name, setter) \
if (SUCCESS == zend_hash_find(Z_ARRVAL_P(details), name, sizeof(name), \
(void**)&tmp)) { \ convert_to_long_ex(tmp); \
hr = setter(T, (DWORD)Z_LVAL_PP(tmp)); \
}
#define WORD_DETAIL(name, setter) \
if (SUCCESS == zend_hash_find(Z_ARRVAL_P(details), name, sizeof(name), \
(void**)&tmp)) { \ convert_to_long_ex(tmp); \
hr = setter(T, (WORD)Z_LVAL_PP(tmp)); \
}
DWORD_DETAIL("MaxRunTime", ITask_SetMaxRunTime);
DWORD_DETAIL("Priority", ITask_SetPriority);
WORD_DETAIL("ErrorRetryCount", ITask_SetErrorRetryCount);
WORD_DETAIL("ErrorRetryInterval", ITask_SetErrorRetryInterval);
DWORD_DETAIL("Flags", ITask_SetFlags);
if (SUCCESS == zend_hash_find(Z_ARRVAL_P(details), "IdleWaitMinutes",
sizeof("IdleWaitMinutes"), (void**)&tmp)) {
convert_to_long_ex(tmp);
w = (DWORD)Z_LVAL_PP(tmp);
if (SUCCESS == zend_hash_find(Z_ARRVAL_P(details), "IdleDeadlineMinutes",
sizeof("IdleDeadlineMinutes"), (void**)&tmp)) {
convert_to_long_ex(tmp);
w2 = (DWORD)Z_LVAL_PP(tmp);
hr = ITask_SetIdleWait(T, w, w2);
ERROR_OUT_IF_FAILED();
}
}
/* if updating an existing task, delete its triggers */
if (!isnew && SUCCEEDED(ITask_GetTriggerCount(T, &trigger_count))) {
int i;
for (i = trigger_count-1; i >= 0; i--) {
hr = ITask_DeleteTrigger(T, i);
ERROR_OUT_IF_FAILED();
}
}
/* now create triggers based on the input */
if (SUCCESS == zend_hash_find(Z_ARRVAL_P(details), "Triggers",
sizeof("Triggers"), (void**)&triggers)) {
HashPosition pos;
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(triggers), &pos);
while (SUCCESS == zend_hash_get_current_data_ex(Z_ARRVAL_PP(triggers), \
(void**)&trigger, &pos)) { TASK_TRIGGER trigdat;
WORD itrig;
ITT = NULL;
hr = ITask_CreateTrigger(T, &itrig, &ITT);
ERROR_OUT_IF_FAILED();
memset(&trigdat, 0, sizeof(trigdat));
trigdat.cbTriggerSize = sizeof(trigdat);
#define WORD_TRIGGER(name, member) \
if (SUCCESS == zend_hash_find(Z_ARRVAL_PP(trigger), name, sizeof(name), \
(void**)&tmp)) { \ convert_to_long_ex(tmp); \
trigdat.member = (WORD)Z_LVAL_PP(tmp); \
printf("WORD_TRIGGER(%s %d)\n", name, trigdat.member); \
}
#define DWORD_TRIGGER(name, member) \
if (SUCCESS == zend_hash_find(Z_ARRVAL_PP(trigger), name, sizeof(name), \
(void**)&tmp)) { \ convert_to_long_ex(tmp); \
trigdat.member = (DWORD)Z_LVAL_PP(tmp); \
printf("DWORD_TRIGGER(%s %d)\n", name, trigdat.member); \
}
WORD_TRIGGER("BeginYear", wBeginYear);
WORD_TRIGGER("BeginMonth", wBeginMonth);
WORD_TRIGGER("BeginDay", wBeginDay);
WORD_TRIGGER("EndYear", wEndYear);
WORD_TRIGGER("EndMonth", wEndMonth);
WORD_TRIGGER("EndDay", wEndDay);
WORD_TRIGGER("StartHour", wStartHour);
WORD_TRIGGER("StartMinute", wStartMinute);
DWORD_TRIGGER("MinutesDuration", MinutesDuration);
DWORD_TRIGGER("MinutesInterval", MinutesInterval);
DWORD_TRIGGER("Flags", rgFlags);
DWORD_TRIGGER("TriggerType", TriggerType);
WORD_TRIGGER("RandomMinutesInterval", wRandomMinutesInterval);
switch (trigdat.TriggerType) {
case TASK_TIME_TRIGGER_DAILY:
WORD_TRIGGER("Daily.DaysInterval", Type.Daily.DaysInterval);
break;
case TASK_TIME_TRIGGER_WEEKLY:
WORD_TRIGGER("Weekly.WeeksInterval", Type.Weekly.WeeksInterval);
WORD_TRIGGER("Weekly.DaysOfTheWeek", Type.Weekly.rgfDaysOfTheWeek);
break;
case TASK_TIME_TRIGGER_MONTHLYDATE:
WORD_TRIGGER("MonthlyDate.Days", Type.MonthlyDate.rgfDays);
WORD_TRIGGER("MonthlyDate.Months", Type.MonthlyDate.rgfMonths);
break;
case TASK_TIME_TRIGGER_MONTHLYDOW:
WORD_TRIGGER("MonthlyDOW.WhichWeek", Type.MonthlyDOW.wWhichWeek);
WORD_TRIGGER("MonthlyDOW.DaysOfTheWeek", Type.MonthlyDOW.rgfDaysOfTheWeek);
WORD_TRIGGER("MonthlyDOW.Months", Type.MonthlyDOW.rgfMonths);
break;
case TASK_EVENT_TRIGGER_ON_IDLE:
case TASK_EVENT_TRIGGER_AT_SYSTEMSTART:
case TASK_EVENT_TRIGGER_AT_LOGON:
trigdat.wBeginYear = 1999;
trigdat.wBeginMonth = 1;
trigdat.wBeginDay = 1;
break;
}
hr = ITaskTrigger_SetTrigger(ITT, &trigdat);
ERROR_OUT_IF_FAILED();
zend_hash_move_forward_ex(Z_ARRVAL_PP(triggers), &pos);
}
}
/* save the changes */
hr = ITask_QueryInterface(T, &IID_IPersistFile, (void**)&IPF);
ERROR_OUT_IF_FAILED();
hr = IPersistFile_Save(IPF, NULL, TRUE);
IPersistFile_Release(IPF);
out:
if (SUCCEEDED(hr)) {
RETVAL_TRUE;
} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed at line %d with code 0x%08x\n", \
error_line, hr); RETVAL_FALSE;
}
if (ITT) {
ITaskTrigger_Release(ITT);
}
ITask_Release(T);
}
/* }}} */
static function_entry functions[] = {
PHP_FE(win32_scheduler_enum_tasks, NULL)
PHP_FE(win32_scheduler_run, NULL)
PHP_FE(win32_scheduler_get_task_info, NULL)
PHP_FE(win32_scheduler_set_task_info, NULL)
PHP_FE(win32_scheduler_delete_task, NULL)
{NULL, NULL, NULL}
};
static PHP_MINIT_FUNCTION(win32scheduler)
{
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_REALTIME_PRIORITY", REALTIME_PRIORITY_CLASS, \
CONST_CS|CONST_PERSISTENT); REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_HIGH_PRIORITY", \
HIGH_PRIORITY_CLASS, CONST_CS|CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_NORMAL_PRIORITY", NORMAL_PRIORITY_CLASS, \
CONST_CS|CONST_PERSISTENT); REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_IDLE_PRIORITY", \
IDLE_PRIORITY_CLASS, CONST_CS|CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_FLAG_INTERACTIVE", TASK_FLAG_INTERACTIVE, \
CONST_CS|CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_FLAG_DELETE_WHEN_DONE", \
TASK_FLAG_DELETE_WHEN_DONE, CONST_CS|CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_FLAG_DISABLED", TASK_FLAG_DISABLED, \
CONST_CS|CONST_PERSISTENT); REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_FLAG_HIDDEN", \
TASK_FLAG_HIDDEN, CONST_CS|CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_FLAG_RUN_ONLY_IF_LOGGED_ON", \
TASK_FLAG_RUN_ONLY_IF_LOGGED_ON, CONST_CS|CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_FLAG_START_ONLY_IF_IDLE", \
TASK_FLAG_START_ONLY_IF_IDLE, CONST_CS|CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_FLAG_SYSTEM_REQUIRED", \
TASK_FLAG_SYSTEM_REQUIRED, CONST_CS|CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_FLAG_KILL_ON_IDLE_END", \
TASK_FLAG_KILL_ON_IDLE_END, CONST_CS|CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_FLAG_RESTART_ON_IDLE_RESUME", \
TASK_FLAG_RESTART_ON_IDLE_RESUME, CONST_CS|CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_FLAG_DONT_START_IF_ON_BATTERIES", \
TASK_FLAG_DONT_START_IF_ON_BATTERIES, CONST_CS|CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_FLAG_KILL_IF_GOING_ON_BATTERIES", \
TASK_FLAG_KILL_IF_GOING_ON_BATTERIES, CONST_CS|CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_FLAG_RUN_IF_CONNECTED_TO_INTERNET", \
TASK_FLAG_RUN_IF_CONNECTED_TO_INTERNET, CONST_CS|CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_TASK_READY", SCHED_S_TASK_READY, \
CONST_CS|CONST_PERSISTENT); REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_TASK_RUNNING", \
SCHED_S_TASK_RUNNING, CONST_CS|CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_TASK_NOT_SCHEDULED", \
SCHED_S_TASK_NOT_SCHEDULED, CONST_CS|CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_TRIGGER_HAS_END_DATE", \
TASK_TRIGGER_FLAG_HAS_END_DATE, CONST_CS|CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_TRIGGER_KILL_AT_DURATION_END", \
TASK_TRIGGER_FLAG_KILL_AT_DURATION_END, CONST_CS|CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_TRIGGER_DISABLED", \
TASK_TRIGGER_FLAG_DISABLED, CONST_CS|CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_TRIGGER_ONCE", TASK_TIME_TRIGGER_ONCE, \
CONST_CS|CONST_PERSISTENT); REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_TRIGGER_DAILY", \
TASK_TIME_TRIGGER_DAILY, CONST_CS|CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_TRIGGER_MONTHLYDATE", \
TASK_TIME_TRIGGER_MONTHLYDATE, CONST_CS|CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_TRIGGER_MONTHLYDOW", \
TASK_TIME_TRIGGER_MONTHLYDOW, CONST_CS|CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_TRIGGER_ON_IDLE", TASK_EVENT_TRIGGER_ON_IDLE, \
CONST_CS|CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_TRIGGER_AT_SYSTEMSTART", \
TASK_EVENT_TRIGGER_AT_SYSTEMSTART, CONST_CS|CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_TRIGGER_AT_LOGON", \
TASK_EVENT_TRIGGER_AT_LOGON, CONST_CS|CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_SUNDAY", TASK_SUNDAY, \
CONST_CS|CONST_PERSISTENT); REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_MONDAY", \
TASK_MONDAY, CONST_CS|CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_TUESDAY", TASK_TUESDAY, \
CONST_CS|CONST_PERSISTENT); REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_WEDNESDAY", \
TASK_WEDNESDAY, CONST_CS|CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_THURSDAY", TASK_THURSDAY, \
CONST_CS|CONST_PERSISTENT); REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_FRIDAY", \
TASK_FRIDAY, CONST_CS|CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_SATURDAY", TASK_SATURDAY, \
CONST_CS|CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_JANUARY", TASK_JANUARY, \
CONST_CS|CONST_PERSISTENT); REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_FEBRUARY", \
TASK_FEBRUARY, CONST_CS|CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_MARCH", TASK_MARCH, \
CONST_CS|CONST_PERSISTENT); REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_APRIL", \
TASK_APRIL, CONST_CS|CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_MAY", TASK_MAY, CONST_CS|CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_JUNE", TASK_JUNE, CONST_CS|CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_JULY", TASK_JULY, CONST_CS|CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_AUGUST", TASK_AUGUST, \
CONST_CS|CONST_PERSISTENT); REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_SEPTEMBER", \
TASK_SEPTEMBER, CONST_CS|CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_OCTOBER", TASK_OCTOBER, \
CONST_CS|CONST_PERSISTENT); REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_NOVEMBER", \
TASK_NOVEMBER, CONST_CS|CONST_PERSISTENT); \
REGISTER_LONG_CONSTANT("WIN32_SCHEDULER_DECEMBER", TASK_DECEMBER, \
CONST_CS|CONST_PERSISTENT);
return SUCCESS;
}
static PHP_MINFO_FUNCTION(win32scheduler)
{
php_info_print_table_start();
php_info_print_table_header(2, "Win32 Scheduler support", "enabled");
php_info_print_table_end();
}
zend_module_entry win32scheduler_module_entry = {
STANDARD_MODULE_HEADER,
"win32scheduler",
functions,
PHP_MINIT(win32scheduler),
NULL,
NULL,
NULL,
PHP_MINFO(win32scheduler),
"0.1",
STANDARD_MODULE_PROPERTIES
};
#ifdef COMPILE_DL_WIN32SCHEDULER
ZEND_GET_MODULE(win32scheduler)
#endif
--
PECL CVS Mailing List
To unsubscribe, visit: http://www.php.net/unsub.php
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic