void main (void)
{
QMSG qmsg;
HMQ hmq;
HWND hwndClient;
ULONG flFrameFlags;
WinInitialize(0);
hmq = WinCreateMsgQueue(hab, 0);
/* get access to shared memory */
DosGetNamedSharedMem((PVOID*)&memptr, MEM_NAME, PAG_READ);
if (!memptr)
WinMessageBox(HWND_DESKTOP, HWND_DESKTOP,
" FreeType/2 is not running!",
"Error", 0, MB_OK | MB_ERROR);
else {
meminfo = memptr->address;
if (meminfo->signature != 0x46524545)
WinMessageBox(HWND_DESKTOP, HWND_DESKTOP,
" FreeType/2 is not running!",
"Error", 0, MB_OK | MB_ERROR);
else {
flFrameFlags = FCF_TITLEBAR | FCF_SYSMENU |
FCF_TASKLIST ;
WinRegisterClass(hab, "MyClass",
(PFNWP) ClientWndProc,
CS_SIZEREDRAW, 0);
hwndFrame = WinCreateStdWindow(HWND_DESKTOP,
WS_VISIBLE,
&flFrameFlags,
"MyClass", "FreeType/2 Heap Usage",
0, (HMODULE) NULL,
0, &hwndClient);
WinSetVisibleRegionNotify(hwndClient, TRUE);
/* make titlebar text look better */
WinSetPresParam(WinWindowFromID(hwndFrame, FID_TITLEBAR),
PP_FONTNAMESIZE, 9, (PVOID)"8.Helv");
WinSetWindowPos(hwndFrame, NULLHANDLE, 0, 0, 350, 42,
SWP_MOVE | SWP_SIZE | SWP_SHOW);
while (WinGetMsg(hab, &qmsg, (HWND) NULL, 0, 0))
WinDispatchMsg(hab, &qmsg);
WinSetVisibleRegionNotify(hwndClient, FALSE);
}
}
/* free shared memory block */
DosFreeMem(memptr);
WinDestroyWindow(hwndFrame);
WinDestroyMsgQueue(hmq);
WinTerminate(hab);
}
VOID ExplainParams(VOID)
{
BOOL f = FALSE;
CHAR szMsg[256];
GetNLSString(szMsg, sizeof(szMsg), ID_NDSI_SYNTAX);
if (WinMessageBox(HWND_DESKTOP, HWND_DESKTOP,
szMsg,
(PSZ)NETSCDDE_TITLE,
0, MB_YESNO | MB_MOVEABLE)
== MBID_YES)
{
// tell xwp to display the help
PXWPGLOBALSHARED pXwpGlobalShared = NULL;
if (!(DosGetNamedSharedMem((PVOID*)&pXwpGlobalShared,
SHMEM_XWPGLOBAL,
PAG_READ | PAG_WRITE)))
{
f = WinPostMsg(pXwpGlobalShared->hwndAPIObject,
APIM_SHOWHELPPANEL,
(MPARAM)ID_XSH_NETSCAPEDDE,
0);
DosFreeMem(pXwpGlobalShared);
}
if (!f)
DisplayError("Cannot open the %s online help. Maybe XWorkplace is not installed or not running.",
NETSCDDE_TITLE);
}
}
int GetClipText(ClipData *cd) {
int rc;
ULONG PostCount;
char *mem;
rc = DosOpenMutexSem(SEM_PREFIX "CLIPSYN", &hmtxSyn);
if (rc != 0) return -1;
rc = DosOpenEventSem(SEM_PREFIX "CLIPGET", &hevGet);
if (rc != 0) return -1;
/* rc = DosOpenEventSem(SEM_PREFIX "CLIPPUT", &hevPut);*/
/* if (rc != 0) return -1;*/
rc = DosOpenEventSem(SEM_PREFIX "CLIPEND", &hevEnd);
if (rc != 0) return -1;
DosRequestMutexSem(hmtxSyn, SEM_INDEFINITE_WAIT);
DosResetEventSem(hevEnd, &PostCount);
DosPostEventSem(hevGet);
DosWaitEventSem(hevEnd, SEM_INDEFINITE_WAIT);
if (0 == DosGetNamedSharedMem((void **)&mem, MEM_PREFIX "CLIPDATA", PAG_READ | PAG_WRITE)) {
cd->fLen = *(ULONG*)mem;
cd->fChar = strdup(mem + 4);
DosFreeMem(mem);
} else {
cd->fLen = 0;
cd->fChar = 0;
}
DosPostEventSem(hevGet);
DosReleaseMutexSem(hmtxSyn);
/* DosCloseEventSem(hevPut);*/
DosCloseEventSem(hevGet);
DosCloseEventSem(hevEnd);
DosCloseMutexSem(hmtxSyn);
return 0;
}
//save current settings to the given ini file
BOOL CBZSave(HINI hIni, char szClass[], PVOID pData, char szCustomName[])
{
PLUGINSHARE *pPluginShare;
char szShareName[32];
char szSaveName[128];
pPluginShare = (PLUGINSHARE *) pData;
//if null, this is a default apply, so load shared memory.
if (pPluginShare == NULL)
{
strcpy(szShareName, PLUGIN_SHARE);
strcat(szShareName, szClass);
// if shared mem is not available, try allocating temporary space!
if (DosGetNamedSharedMem((PPVOID) & pPluginShare, szShareName, PAG_READ | PAG_WRITE) != NO_ERROR)
{
//try Allocating temporary space for the plugin data so we can write to the ini file
if (DosAllocMem((PPVOID) & pPluginShare,
sizeof(PLUGINSHARE),
PAG_READ | PAG_WRITE | PAG_COMMIT) != NO_ERROR)
return (FALSE); //No Good... can't save.
}
//write pPluginShare to the ini file!
strcpy(szSaveName, szClass);
strcat(szSaveName, "_CBZLINESPlugin");
PrfWriteProfileData(hIni,
"UserOptionsData",
szSaveName,
pPluginShare,
sizeof(PLUGINSHARE));
DosFreeMem(pPluginShare);
}
else
{
strcpy(szSaveName, szCustomName);
strcat(szSaveName, "_");
strcat(szSaveName, szClass);
strcat(szSaveName, "_CBZLINESPlugin");
PrfWriteProfileData(hIni,
"CustomOptionsData",
szSaveName,
pPluginShare,
sizeof(PLUGINSHARE));
}
return (TRUE);
}
SOM_Scope HMODULE SOMLINK WPSamFM_clsQueryModuleHandle (M_WPSamF *somSelf)
{
/* M_WPSamFData *somThis = M_WPSamFGetData (somSelf); */
M_WPSamFMethodDebug ("M_WPSamF","WPSamFM_clsQueryModuleHandle");
if(!hevPrfResetLock)
if(DosOpenEventSem (HEV_PRFRESETLOCK, &hevPrfResetLock))
if(DosCreateEventSem(HEV_PRFRESETLOCK, // Name
&hevPrfResetLock, // Pointer to sem
0, // Not used with named sems
TRUE)) // Initial state (TRUE = POSTED)
hevPrfResetLock = 0;
if(!pShareInitOS2)
if (DosGetNamedSharedMem ((PPVOID) &pShareInitOS2,
SHARE_INITOS2,
PAG_READ | PAG_WRITE))
pShareInitOS2 = 0;
if(!hevSammy)
if (DosOpenEventSem (HEV_SAMMY, &hevSammy))
hevSammy = 0;
if (hmod == NULLHANDLE)
{
zString zsPathName;
/*
* Retrieve registered pathname of our module (DLL) and query the
* module handle.
*/
zsPathName =
_somLocateClassFile (SOMClassMgrObject, SOM_IdFromString (CLASSNAME),
WPSamF_MajorVersion, WPSamF_MinorVersion);
if (DosQueryModuleHandle (zsPathName, &hmod))
{
DebugE (D_SOM, "_clsQueryModuleHandle", "Failed to load module");
hmod = NULLHANDLE;
}
} /* end if (hmod == NULLHANDLE) */
DebugULd (D_SOM, "_clsQueryModuleHandle", "hmod", hmod);
return (hmod);
}
ICQSHAREMEM * EXPENTRY icqIPCGetSharedBlock(void)
{
int rc = -1;
ICQSHAREMEM *shareBlock;
if(DosGetNamedSharedMem((PPVOID) &shareBlock,PWICQ_SHAREMEM,PAG_READ|PAG_WRITE))
return NULL;
if(shareBlock->sz == sizeof(ICQSHAREMEM) && shareBlock->si == sizeof(ICQINSTANCE))
return shareBlock;
DosFreeMem(shareBlock);
return NULL;
}
// setuptcp( )
//
// Setup socket, bind, and set socket to timeout recv after 2 seconds
//
int setuptcp( )
{
// int retcode = 0;
int flag =1;
int syslport;
struct timeval recvtimeout;
struct sockaddr_in tcp_in;
struct servent *sp;
sp = getservbyname("syslog" , "udp");
syslport = htons(sp->s_port);
// Setup socket - descriptor tcpsocket
tcpsocket = socket(PF_INET, SOCK_DGRAM, 0);
if(tcpsocket == -1) return(1);
// clear tcp_in and set values
memset(&tcp_in, 0, sizeof(tcp_in));
tcp_in.sin_len = sizeof(tcp_in);
tcp_in.sin_family = AF_INET;
tcp_in.sin_addr.s_addr = inet_addr(prgoptions->sendIP);//htonl(INADDR_ANY);
tcp_in.sin_port = syslport;
// setup recv 2 minute timeout
recvtimeout.tv_sec = 1;
recvtimeout.tv_usec = 0;
// set socket recv timeout and reuse
if(setsockopt(tcpsocket, SOL_SOCKET, SO_RCVTIMEO, (char *)&recvtimeout,
sizeof(struct timeval)) == -1) return(1);
if (setsockopt(tcpsocket, SOL_SOCKET, SO_REUSEPORT,(const char*)&flag,
sizeof(flag))) return(1);
// bind to socket
if(bind(tcpsocket, (struct sockaddr *)&tcp_in, sizeof(tcp_in))) return(1);
// get access to the buffer
if(DosGetNamedSharedMem((PPVOID)&pShareMem,
SHMEM_NAME, PAG_READ | PAG_WRITE) != 0) return(3);
return 0;
} //$* end of setuptcp
int main (VOID)
{
PVOID pvShrObject = NULL; /* Pointer to shared memory object */
PSZ pszMemName = "\\SHAREMEM\\MYTOOL\\APPLICAT.DAT"; /* Object name */
PVOID pvAltObject = NULL; /* Alternate pointer to shared memory */
APIRET rc = NO_ERROR; /* Return code */
ULONG ulObjSize = 1024; /* Size (system rounds to 4096 - page bdy) */
rc = DosAllocSharedMem(&pvShrObject, /* Pointer to object pointer */
pszMemName, /* Name for shared memory */
ulObjSize, /* Desired size of object */
PAG_COMMIT | /* Commit memory */
PAG_WRITE ); /* Allocate memory as read/write */
if (rc != NO_ERROR) {
printf("DosAllocSharedMem error: return code = %u\n",rc);
return 1;
}
strcpy(pvShrObject, "Write your shared application data here.");
/* Get the address of the shared memory and reference it that way.
(Done for illustrative purposes only, this is how another process
would go about accessing the named shared memory.) */
rc = DosGetNamedSharedMem(&pvAltObject, /* Pointer to pointer of object */
pszMemName, /* Name of shared memory */
PAG_READ); /* Want read-only access */
if (rc != NO_ERROR) {
printf("DosGetNamedSharedMem error: return code = %u\n",rc);
return 1;
}
printf("Shared data read was \"%s\"\n",pvAltObject);
rc = DosFreeMem(pvShrObject);
if (rc != NO_ERROR) {
printf("DosFreeMem error: return code = %u\n",rc);
return 1;
}
return NO_ERROR;
}
APR_DECLARE(apr_status_t) apr_shm_attach(apr_shm_t **m,
const char *filename,
apr_pool_t *pool)
{
int rc;
apr_shm_t *newm = (apr_shm_t *)apr_palloc(pool, sizeof(apr_shm_t));
char *name = NULL;
ULONG flags = PAG_READ|PAG_WRITE;
newm->pool = pool;
name = apr_pstrcat(pool, "\\SHAREMEM\\", filename, NULL);
rc = DosGetNamedSharedMem(&(newm->memblock), name, flags);
if (rc) {
return APR_FROM_OS_ERROR(rc);
}
*m = newm;
return APR_SUCCESS;
}
int EXPENTRY icqIPCQueryInstance(ULONG *instance)
{
int rc = -1;
ICQSHAREMEM *shareBlock;
int f;
rc = DosGetNamedSharedMem((PPVOID) &shareBlock,PWICQ_SHAREMEM,PAG_READ|PAG_WRITE);
DBGTrace(rc);
if(rc)
return rc;
if(shareBlock->sz == sizeof(ICQSHAREMEM) && shareBlock->si == sizeof(ICQINSTANCE))
{
/* Tenho um bloco valido, procuro por um UIN ativo */
*instance = 0;
rc = ERROR_FILE_NOT_FOUND;
for(f=0; f < PWICQ_MAX_INSTANCES && !*instance;f++)
{
if( (shareBlock->i+f)->uin )
{
rc = 0;
*instance = (shareBlock->i+f)->uin;
}
}
}
else
{
rc = ERROR_INVALID_BLOCK;
}
DosFreeMem(shareBlock);
return rc;
}
//change current settings.
BOOL CBZApply(char szClass[], KEY_VALUE * kv, int count, int enabledState, PVOID pData)
{
int i;
PLUGINSHARE *pPluginShare;
char szShareName[32];
char szSaveName[32];
BOOL bDefaultApply = FALSE;
pPluginShare = (PLUGINSHARE *) pData;
//if null, this is a default apply, so load shared memory.
if (pPluginShare == NULL)
{
strcpy(szShareName, PLUGIN_SHARE);
strcat(szShareName, szClass);
// if shared mem is not available, try allocating temporary space!
if (DosGetNamedSharedMem((PPVOID) & pPluginShare, szShareName, PAG_READ | PAG_WRITE) != NO_ERROR)
{
return FALSE;
}
bDefaultApply = TRUE;
}
pPluginShare->sEnabledStates = enabledState;
//loop through each key/value pair and set appropriate parameters
for (i = 0; i < count; i++)
{
if (strcmp(kv[i].key, "ImageFile") == 0)
{
strcpy(pPluginShare->szImageFile, kv[i].value);
}
} //end for loop
if (bDefaultApply)
DosFreeMem(pPluginShare);
return TRUE;
}
int main (int argc, char *argv[])
{
APIRET rc;
PCHAR pcEnv;
PRFPROFILE prfProfile;
#ifdef DEBUG
ulDebugMask = 0xFFFFFFFF;
#endif /* DEBUG */
hab = WinInitialize(0);
hmq = WinCreateMsgQueue(hab, 0);
DebugS (1, "PM Interface initialized");
/* Shared Memory organisieren */
if (rc = DosGetNamedSharedMem ((PPVOID) &pShareInitOS2,
SHARE_INITOS2,
PAG_READ | PAG_WRITE))
{
if (rc = DosAllocSharedMem( (PPVOID) &pShareInitOS2, // Pointer to shared mem
SHARE_INITOS2, // Name
CCHSHARE_INITOS2, // Size of shared mem
PAG_COMMIT | PAG_READ | PAG_WRITE)) // Flags
return(1);
else
{
/* Shared Memory initialisieren */
memset (pShareInitOS2, '\0', CCHSHARE_INITOS2);
pShareInitOS2->pszRegFile = (PCHAR) pShareInitOS2 +
sizeof(*pShareInitOS2);
strcpy (pShareInitOS2->pszRegFile,
DosScanEnv (ENV_SYSTEM_INI, &pcEnv) ? "" : pcEnv);
pShareInitOS2->pszRootUserIni = pShareInitOS2->pszRegFile +
strlen(pShareInitOS2->pszRegFile) + 1;
pShareInitOS2->pszRootSystemIni = pShareInitOS2->pszRootUserIni + 1;
pShareInitOS2->pszUserIni = pShareInitOS2->pszRootSystemIni + 1;
pShareInitOS2->pszSystemIni = pShareInitOS2->pszUserIni + CCHMAXPATH;
pShareInitOS2->pszEnvironment = pShareInitOS2->pszSystemIni + CCHMAXPATH;
}
}
DebugS (1, "Shared Memory initialized");
/* Semaphoren organisieren */
rc = DosOpenEventSem (HEV_SAMMY, &hevSammy);
if( rc )
rc = DosCreateEventSem( HEV_SAMMY, // Name
&hevSammy, // Pointer to sem
0, // Not used with named sems
FALSE); // Initial state (FALSE = SET)
else /* Sammy ist bereits installiert */
{
pShareInitOS2->pszEnvironment[0] = '\0';
pShareInitOS2->pszEnvironment[1] = '\0';
pShareInitOS2->pszSystemIni[0] = '\0';
pShareInitOS2->pszUserIni[0] = '\0';
DosPostEventSem(hevSammy);
goto Exit;
}
if( rc )
{
intSammyRetCode = rc;
goto Exit;
}
rc = DosOpenEventSem (HEV_PRFRESETLOCK, &hevPrfResetLock);
if( rc )
rc = DosCreateEventSem( HEV_PRFRESETLOCK, // Name
&hevPrfResetLock, // Pointer to sem
0, // Not used with named sems
TRUE); // Initial state (TRUE = POSTED)
if( rc )
{
intSammyRetCode = rc;
goto Exit;
}
DebugS (1, "Semaphores initialized");
ChangeWPS(pShareInitOS2->pszUserIni, pShareInitOS2->pszSystemIni);
/* Hintergrundloop starten, das Shell mit aktueller Env. startet */
DosCreateThread (&tid1,
(PFNTHREAD) thStartProg,
(ULONG) ((argc > 1) ? argv[1] : ""),
0,
THREADSTACK);
DebugS (1, "Background loop started");
/* Hintergrundloop starten, das jeweils nach L�schen einer Semaphore */
/* einen prfReset initiiert */
DosCreateThread (&tid2,
(PFNTHREAD) thSwitch,
(ULONG) 0,
0,
THREADSTACK);
while (WinGetMsg (hab, &qmsg, 0, 0, 0))
WinDispatchMsg (hab, &qmsg);
if (intSammyRetCode)
{
DosKillThread (tid1);
DosKillThread (tid2);
WinSetObjectData(WinQueryObject("<WP_DESKTOP>"), "WORKAREA=NO");
WinPostMsg(WinQueryWindow(HWND_DESKTOP, QW_BOTTOM), WM_CLOSE, 0, 0);
WinAlarm (HWND_DESKTOP, WA_ERROR);
prfProfile.pszSysName = (DosScanEnv (ENV_SYSTEM_INI, &pcEnv) ? "" : pcEnv);
prfProfile.pszUserName = (DosScanEnv (ENV_USER_INI, &pcEnv) ? "" : pcEnv);
prfProfile.cchUserName = strlen(prfProfile.pszUserName);
prfProfile.cchSysName = strlen(prfProfile.pszSysName);
DosSleep (1000);
DosKillProcess( DKP_PROCESSTREE, ulShellID );
if ( !PrfReset(hab, &prfProfile))
WinSetObjectData(WinQueryObject("<WP_DESKTOP>"), "OPEN=ICON;WORKAREA=YES");
}
Exit:
WinDestroyMsgQueue(hmq);
WinTerminate(hab);
DebugS (1, "Application terminated");
return intSammyRetCode;
}
void ap_mpm_child_main(apr_pool_t *pconf)
{
ap_listen_rec *lr = NULL;
int requests_this_child = 0;
int rv = 0;
unsigned long ulTimes;
int my_pid = getpid();
ULONG rc, c;
HQUEUE workq;
apr_pollset_t *pollset;
int num_listeners;
TID server_maint_tid;
void *sb_mem;
/* Stop Ctrl-C/Ctrl-Break signals going to child processes */
DosSetSignalExceptionFocus(0, &ulTimes);
set_signals();
/* Create pool for child */
apr_pool_create(&pchild, pconf);
ap_run_child_init(pchild, ap_server_conf);
/* Create an event semaphore used to trigger other threads to shutdown */
rc = DosCreateEventSem(NULL, &shutdown_event, 0, FALSE);
if (rc) {
ap_log_error(APLOG_MARK, APLOG_ERR, APR_FROM_OS_ERROR(rc), ap_server_conf,
"unable to create shutdown semaphore, exiting");
clean_child_exit(APEXIT_CHILDFATAL);
}
/* Gain access to the scoreboard. */
rc = DosGetNamedSharedMem(&sb_mem, ap_scoreboard_fname,
PAG_READ|PAG_WRITE);
if (rc) {
ap_log_error(APLOG_MARK, APLOG_ERR, APR_FROM_OS_ERROR(rc), ap_server_conf,
"scoreboard not readable in child, exiting");
clean_child_exit(APEXIT_CHILDFATAL);
}
ap_calc_scoreboard_size();
ap_init_scoreboard(sb_mem);
/* Gain access to the accpet mutex */
rc = DosOpenMutexSem(NULL, &ap_mpm_accept_mutex);
if (rc) {
ap_log_error(APLOG_MARK, APLOG_ERR, APR_FROM_OS_ERROR(rc), ap_server_conf,
"accept mutex couldn't be accessed in child, exiting");
clean_child_exit(APEXIT_CHILDFATAL);
}
/* Find our pid in the scoreboard so we know what slot our parent allocated us */
for (child_slot = 0; ap_scoreboard_image->parent[child_slot].pid != my_pid && child_slot < HARD_SERVER_LIMIT; child_slot++);
if (child_slot == HARD_SERVER_LIMIT) {
ap_log_error(APLOG_MARK, APLOG_ERR, 0, ap_server_conf,
"child pid not found in scoreboard, exiting");
clean_child_exit(APEXIT_CHILDFATAL);
}
ap_my_generation = ap_scoreboard_image->parent[child_slot].generation;
memset(ap_scoreboard_image->servers[child_slot], 0, sizeof(worker_score) * HARD_THREAD_LIMIT);
/* Set up an OS/2 queue for passing connections & termination requests
* to worker threads
*/
rc = DosCreateQueue(&workq, QUE_FIFO, apr_psprintf(pchild, "/queues/httpd/work.%d", my_pid));
if (rc) {
ap_log_error(APLOG_MARK, APLOG_ERR, APR_FROM_OS_ERROR(rc), ap_server_conf,
"unable to create work queue, exiting");
clean_child_exit(APEXIT_CHILDFATAL);
}
/* Create initial pool of worker threads */
for (c = 0; c < ap_min_spare_threads; c++) {
// ap_scoreboard_image->servers[child_slot][c].tid = _beginthread(worker_main, NULL, 128*1024, (void *)c);
}
/* Start maintenance thread */
server_maint_tid = _beginthread(server_maintenance, NULL, 32768, NULL);
/* Set up poll */
for (num_listeners = 0, lr = ap_listeners; lr; lr = lr->next) {
num_listeners++;
}
apr_pollset_create(&pollset, num_listeners, pchild, 0);
for (lr = ap_listeners; lr != NULL; lr = lr->next) {
apr_pollfd_t pfd = { 0 };
pfd.desc_type = APR_POLL_SOCKET;
pfd.desc.s = lr->sd;
pfd.reqevents = APR_POLLIN;
pfd.client_data = lr;
apr_pollset_add(pollset, &pfd);
}
/* Main connection accept loop */
do {
apr_pool_t *pconn;
worker_args_t *worker_args;
int last_poll_idx = 0;
apr_pool_create(&pconn, pchild);
worker_args = apr_palloc(pconn, sizeof(worker_args_t));
worker_args->pconn = pconn;
if (num_listeners == 1) {
rv = apr_socket_accept(&worker_args->conn_sd, ap_listeners->sd, pconn);
} else {
const apr_pollfd_t *poll_results;
apr_int32_t num_poll_results;
rc = DosRequestMutexSem(ap_mpm_accept_mutex, SEM_INDEFINITE_WAIT);
if (shutdown_pending) {
DosReleaseMutexSem(ap_mpm_accept_mutex);
break;
}
rv = APR_FROM_OS_ERROR(rc);
if (rv == APR_SUCCESS) {
rv = apr_pollset_poll(pollset, -1, &num_poll_results, &poll_results);
DosReleaseMutexSem(ap_mpm_accept_mutex);
}
if (rv == APR_SUCCESS) {
if (last_poll_idx >= num_listeners) {
last_poll_idx = 0;
}
lr = poll_results[last_poll_idx++].client_data;
rv = apr_socket_accept(&worker_args->conn_sd, lr->sd, pconn);
last_poll_idx++;
}
}
if (rv != APR_SUCCESS) {
if (!APR_STATUS_IS_EINTR(rv)) {
ap_log_error(APLOG_MARK, APLOG_ERR, rv, ap_server_conf,
"apr_socket_accept");
clean_child_exit(APEXIT_CHILDFATAL);
}
} else {
DosWriteQueue(workq, WORKTYPE_CONN, sizeof(worker_args_t), worker_args, 0);
requests_this_child++;
}
if (ap_max_requests_per_child != 0 && requests_this_child >= ap_max_requests_per_child)
break;
} while (!shutdown_pending && ap_my_generation == ap_scoreboard_image->global->running_generation);
ap_scoreboard_image->parent[child_slot].quiescing = 1;
DosPostEventSem(shutdown_event);
DosWaitThread(&server_maint_tid, DCWW_WAIT);
if (is_graceful) {
char someleft;
/* tell our worker threads to exit */
for (c=0; c<HARD_THREAD_LIMIT; c++) {
if (ap_scoreboard_image->servers[child_slot][c].status != SERVER_DEAD) {
DosWriteQueue(workq, WORKTYPE_EXIT, 0, NULL, 0);
}
}
do {
someleft = 0;
for (c=0; c<HARD_THREAD_LIMIT; c++) {
if (ap_scoreboard_image->servers[child_slot][c].status != SERVER_DEAD) {
someleft = 1;
DosSleep(1000);
break;
}
}
} while (someleft);
} else {
DosPurgeQueue(workq);
for (c=0; c<HARD_THREAD_LIMIT; c++) {
if (ap_scoreboard_image->servers[child_slot][c].status != SERVER_DEAD) {
DosKillThread(ap_scoreboard_image->servers[child_slot][c].tid);
}
}
}
apr_pool_destroy(pchild);
}
int ApplyPreviewBlock(HWND hwnd, char themeFile[], char szClass[], char szBase[], HINI hIni, int count)
{
CBZSHARE *pCBZShare;
CBZDATA *pCBZData;
PLUGIN_LIST List;
PAPPLYFN pApplyFn;
PINITFN pInitFn;
char szError[CCHMAXPATH];
char szProfile[CCHMAXPATH + 1];
char szFile[CCHMAXPATH + 1];
char szPluginBase[CCHMAXPATH + 1];
char *tempPtr;
int i,j;
// get it for writing, so let's hurry
if (DosGetNamedSharedMem((PPVOID) & pCBZShare, CBZ_SHARE, PAG_READ)
!= NO_ERROR)
{
PSUTErrorFunc(NULLHANDLE, "Error", "ApplyPreviewBlock", "Failed to Get Shared Memory", 0UL);
return count;
}
if ((pCBZData = WinQueryWindowPtr(hwnd, pCBZShare->ulDataOffset)) == NULL)
{
PSUTErrorFunc(NULLHANDLE, "Error", "Couldn't get Window Data", szFile, 0UL);
DosFreeMem(pCBZShare);
return count;
}
DosFreeMem(pCBZShare);
//update the shared memory.
if (strcmp(szClass, "TITLEBAR") == 0)
pCBZData->sTitlebarIndex = count;
else if (strcmp(szClass, "FRAME") == 0)
pCBZData->sFrameBackgroundIndex = count;
else if (strcmp(szClass, "FRAMEBRDR") == 0)
pCBZData->sFrameBorderIndex = count;
else if (strcmp(szClass, "PUSHBUTTON") == 0)
pCBZData->sPushButtonIndex = count;
else if (strcmp(szClass, "RADIOBUTTON") == 0)
pCBZData->sRadioButtonIndex = count;
else if (strcmp(szClass, "CHECKBOX") == 0)
pCBZData->sCheckBoxIndex = count;
else if (strcmp(szClass, "MINMAX") == 0)
pCBZData->sMinMaxIndex = count;
else if (strcmp(szClass, "MENU") == 0)
pCBZData->sMenuIndex = count;
if (!runParser(themeFile, szClass, &List, szError))
{
PSUTErrorFunc(NULLHANDLE, "Error", "ApplyBlock", szError, 0UL);
return count;
}
if (List.cbPlugins <= 0)
return count;
pCBZData->cbPlugins = count + List.cbPlugins;
if (List.cbPlugins > 0)
{
if (strcmp(szClass, "TITLEBAR") == 0)
pCBZData->bTitlebarEnabled = TRUE;
else if (strcmp(szClass, "FRAME") == 0)
pCBZData->bFrameBackgroundEnabled = TRUE;
else if (strcmp(szClass, "FRAMEBRDR") == 0)
pCBZData->bFrameBorderEnabled = TRUE;
else if (strcmp(szClass, "PUSHBUTTON") == 0)
pCBZData->bPushButtonEnabled = TRUE;
else if (strcmp(szClass, "RADIOBUTTON") == 0)
pCBZData->bRadioButtonEnabled = TRUE;
else if (strcmp(szClass, "CHECKBOX") == 0)
pCBZData->bCheckBoxEnabled = TRUE;
else if (strcmp(szClass, "MINMAX") == 0)
pCBZData->bMinMaxEnabled = TRUE;
else if (strcmp(szClass, "MENU") == 0)
pCBZData->bMenuEnabled = TRUE;
}
else
{
if (strcmp(szClass, "TITLEBAR") == 0)
pCBZData->bTitlebarEnabled = FALSE;
else if (strcmp(szClass, "FRAME") == 0)
pCBZData->bFrameBackgroundEnabled = FALSE;
else if (strcmp(szClass, "FRAMEBRDR") == 0)
pCBZData->bFrameBorderEnabled = FALSE;
else if (strcmp(szClass, "PUSHBUTTON") == 0)
pCBZData->bPushButtonEnabled = FALSE;
else if (strcmp(szClass, "RADIOBUTTON") == 0)
pCBZData->bRadioButtonEnabled = FALSE;
else if (strcmp(szClass, "CHECKBOX") == 0)
pCBZData->bCheckBoxEnabled = FALSE;
else if (strcmp(szClass, "MINMAX") == 0)
pCBZData->bMinMaxEnabled = FALSE;
else if (strcmp(szClass, "MENU") == 0)
pCBZData->bMenuEnabled = FALSE;
}
strcpy(szPluginBase, szBase);
strcat(szPluginBase, "plugins\\");
for (j = 0; j < List.cbPlugins; j++)
{
//copy plugin names to shared memory.
strcpy(pCBZData->Plugins[count + j].szPluginDLL,
List.pPluginAttributes[j].szPluginName);
for (i = 0; i < List.pPluginAttributes[j].cbAttributes; i++)
{
//If there is a %CBZBaseDir% in the attribute, replace it with the basePath
if (strstr(List.pPluginAttributes[j].keyValue[i].value, "%CBZBaseDir%") != NULL)
{
//%CBZBaseDir% must be at the start of the string
//allocate space for the new string
tempPtr = (char *) malloc(sizeof(char) * (strlen(szBase) + strlen(List.pPluginAttributes[j].keyValue[i].value) - strlen("%CBZBaseDir%") + 1));
tempPtr[0] = '\0';
strcat(tempPtr, szBase);
sscanf(List.pPluginAttributes[j].keyValue[i].value, "%%CBZBaseDir%%\\%s", szProfile);
strcat(tempPtr, szProfile);
free(List.pPluginAttributes[j].keyValue[i].value);
//replace the old string with the new string.
List.pPluginAttributes[j].keyValue[i].value = tempPtr;
}
}
//plugins might not be in LIBPATH, create full path here.
_makepath(szFile, NULL, szPluginBase, List.pPluginAttributes[j].szPluginName, "DLL");
if (DosLoadModule(szError, sizeof(szError), szFile, &(pCBZData->Plugins[count + j].hModDll)) == NO_ERROR)
{
//Query The Plugin's CBZPluginDataSize Function
if (DosQueryProcAddr(pCBZData->Plugins[count + j].hModDll, 0, "CBZInit",
(PFN *) & (pInitFn)) != NO_ERROR)
{
//error in Plugin's initialization...disable the plugin!
pCBZData->Plugins[count + j].bActiveEnabled = FALSE;
pCBZData->Plugins[count + j].bInactiveEnabled = FALSE;
DosFreeModule(pCBZData->Plugins[count + j].hModDll);
continue; //end this iteration..try next plugin.
}
//Call the Plugins Init function.
if (!pInitFn(hIni, "", szClass, (PVOID *) & (pCBZData->Plugins[count + j].pData)))
{
//error in Plugin's initialization...disable the plugin!
pCBZData->Plugins[count + j].bActiveEnabled = FALSE;
pCBZData->Plugins[count + j].bInactiveEnabled = FALSE;
DosFreeModule(pCBZData->Plugins[count + j].hModDll);
continue; //end this iteration..try next plugin.
}
//Query the Plugin's Window Procedure.
if (DosQueryProcAddr(pCBZData->Plugins[count + j].hModDll, 0, "CBZPluginWndProc",
(PFN *) & (pCBZData->Plugins[count + j].pPluginWndProc)) != NO_ERROR)
{
//error getting the Plugin's WndProc...disable the plugin!
pCBZData->Plugins[count + j].bActiveEnabled = FALSE;
pCBZData->Plugins[count + j].bInactiveEnabled = FALSE;
DosFreeModule(pCBZData->Plugins[count + j].hModDll);
DosFreeMem(pCBZData->Plugins[count + j].pData);
continue; //end this iteration...try next plugin.
}
//Query the address of the plugin's Render function.
if (DosQueryProcAddr(pCBZData->Plugins[count + j].hModDll, 0, "CBZPluginRender",
(PFN *) & (pCBZData->Plugins[count + j].pfnPluginRender)) != NO_ERROR)
{
//Error getting CBZPluginRender function!
pCBZData->Plugins[count + j].bActiveEnabled = FALSE;
pCBZData->Plugins[count + j].bInactiveEnabled = FALSE;
DosFreeModule(pCBZData->Plugins[count + j].hModDll);
DosFreeMem(pCBZData->Plugins[count + j].pData);
continue; //end this iteration...try next plugin.
}
if (DosQueryProcAddr(pCBZData->Plugins[count + j].hModDll, 0, "CBZApply", (PFN *) & pApplyFn) == NO_ERROR)
{
//check return code from this to make sure it was sucessful.. if not disable the plugin
pApplyFn(szClass, (List.pPluginAttributes[j].keyValue),
List.pPluginAttributes[j].cbAttributes,
List.pPluginAttributes[j].enabledState,
pCBZData->Plugins[count + j].pData);
}
else
{
PSUTErrorFunc(NULLHANDLE, "Error", "ApplyPreviewBlock", "Failed Querying Procedure Address for CBZApply", 0UL);
}
}
else
{
PSUTErrorFunc(NULLHANDLE, "Error", "ApplyBlock", "Error Querying Plugin Module.. (Missing?)", 0UL);
pCBZData->cbPlugins = j - 1;
break;
//disable it here
}
}
i = List.cbPlugins;
//delete all the attributes in the plugin/key/value list
CBZFreePLUGIN_LIST(&List);
return count + i;
}
/**
* Initializes the shared structures.
*/
static void shared_init()
{
APIRET arc;
int rc;
arc = DosExitList(EXLST_ADD, ProcessExit);
ASSERT_MSG(arc == NO_ERROR, "%ld", arc);
#if defined(TRACE_ENABLED) && !defined(TRACE_USE_LIBC_LOG)
/*
* Allocate a larger buffer to fit lengthy TRACE messages and disable
* auto-flush on EOL (to avoid breaking lines by stdout operations
* from other threads/processes).
*/
setvbuf(stdout, NULL, _IOFBF, 0x10000);
#endif
while (1)
{
/* First, try to open the mutex */
arc = DosOpenMutexSem(MUTEX_LIBCX, &gMutex);
TRACE("DosOpenMutexSem = %lu\n", arc);
if (arc == NO_ERROR)
{
/*
* Init is (being) done by another process, request the mutex to
* guarantee shared memory is already alloated, then get access to
* it and open shared heap located in that memory.
*/
arc = DosRequestMutexSem(gMutex, SEM_INDEFINITE_WAIT);
ASSERT_MSG(arc == NO_ERROR, "%ld", arc);
if (arc == NO_ERROR)
{
arc = DosGetNamedSharedMem((PPVOID)&gpData, SHAREDMEM_LIBCX, PAG_READ | PAG_WRITE);
TRACE("DosGetNamedSharedMem = %lu\n", arc);
if (arc)
{
/*
* This failure means that another process was too fast to do what
* it wanted and initiated global uninitialization before we got the
* mutex so shared memory was already freed by this time. Retry.
*/
DosReleaseMutexSem(gMutex);
DosCloseMutexSem(gMutex);
continue;
}
/*
* It's an ordinary LIBCx process. Increase coutners.
*/
TRACE("gpData->heap = %p\n", gpData->heap);
ASSERT(gpData->heap);
rc = _uopen(gpData->heap);
ASSERT_MSG(rc == 0, "%d (%d)", rc, errno);
ASSERT(gpData->refcnt);
gpData->refcnt++;
TRACE("gpData->refcnt = %d\n", gpData->refcnt);
}
break;
}
if (arc == ERROR_SEM_NOT_FOUND)
{
/* We are the first process, create the mutex */
arc = DosCreateMutexSem(MUTEX_LIBCX, &gMutex, 0, TRUE);
TRACE("DosCreateMutexSem = %ld\n", arc);
if (arc == ERROR_DUPLICATE_NAME)
{
/* Another process is faster, attempt to open the mutex again */
continue;
}
}
ASSERT_MSG(arc == NO_ERROR, "%ld", arc);
/*
* It's a process that successfully created the main mutex, i.e. the first
* LIBCx process. Proceed with the initial setup by allocating shared
* memory and heap.
*/
/* Allocate shared memory */
arc = DosAllocSharedMem((PPVOID)&gpData, SHAREDMEM_LIBCX, HEAP_SIZE,
PAG_READ | PAG_WRITE | OBJ_ANY);
TRACE("DosAllocSharedMem(OBJ_ANY) = %ld\n", arc);
if (arc && arc != ERROR_ALREADY_EXISTS)
{
/* High memory may be unavailable, try w/o OBJ_ANY */
arc = DosAllocSharedMem((PPVOID)&gpData, SHAREDMEM_LIBCX, HEAP_SIZE,
PAG_READ | PAG_WRITE);
TRACE("DosAllocSharedMem = %ld\n", arc);
}
ASSERT_MSG(arc == NO_ERROR, "%ld", arc);
TRACE("gpData %p\n", gpData);
/* Commit the initial block */
arc = DosSetMem(gpData, HEAP_INIT_SIZE, PAG_DEFAULT | PAG_COMMIT);
ASSERT_MSG(arc == NO_ERROR, "%ld", arc);
gpData->size = HEAP_INIT_SIZE;
/* Create shared heap */
gpData->heap = _ucreate(gpData + 1, HEAP_INIT_SIZE - sizeof(*gpData),
_BLOCK_CLEAN, _HEAP_REGULAR | _HEAP_SHARED,
mem_alloc, NULL);
TRACE("gpData->heap = %p\n", gpData->heap);
ASSERT(gpData->heap);
rc = _uopen(gpData->heap);
ASSERT_MSG(rc == 0, "%d (%d)", rc, errno);
gpData->refcnt = 1;
/* Initialize common structures */
GLOBAL_NEW_ARRAY(gpData->procs, PROC_DESC_HASH_SIZE);
TRACE("gpData->procs = %p\n", gpData->procs);
ASSERT(gpData->procs);
GLOBAL_NEW_ARRAY(gpData->files, FILE_DESC_HASH_SIZE);
TRACE("gpData->files = %p\n", gpData->files);
ASSERT(gpData->files);
break;
}
/*
* Perform common initialization (both for the first and ordinary processes).
*/
/* Make sure a process description for this process is created */
ProcDesc *proc = get_proc_desc(getpid());
ASSERT(proc);
/* Initialize individual components */
mmap_init(proc);
fcntl_locking_init(proc);
/* Check if it's a spawn2 wrapper (e.g. spawn2-wrapper.c) */
{
char dll[CCHMAXPATH + sizeof(SPAWN2_WRAPPERNAME) + 1];
if (get_module_name(dll, sizeof(dll)))
{
strcpy(_getname(dll), SPAWN2_WRAPPERNAME);
char exe[CCHMAXPATH + 1];
if (_execname(exe, sizeof(exe)) == 0 && stricmp(dll, exe) == 0)
{
proc->flags |= Proc_Spawn2Wrapper;
TRACE("spawn2 wrapper\n");
/* Make sure the semaphore is available (needed for spawn2-wrapper.c) */
ASSERT(gpData->spawn2_sem);
global_spawn2_sem(proc);
}
}
}
DosReleaseMutexSem(gMutex);
TRACE("done\n");
}
BOOL CandyBarZFrameBorderPaintProc(HWND hwnd, RECTL * rect, HPS hpsFrame, short sState)
{
CBZDATA *pCBZData;
CBZSHARE *pCBZShare;
PSPAINT *pPaint;
TEMPPAINT *pFramePaint;
BOOL rc;
int i;
ULONG ulDataOffset;
if (DosGetNamedSharedMem((PPVOID) & pCBZShare, CBZ_SHARE, PAG_READ) != NO_ERROR)
{
return (FALSE);
}
ulDataOffset = pCBZShare->ulDataOffset;
DosFreeMem(pCBZShare);
// get window data
if ((pCBZData = WinQueryWindowPtr(CandyBarZGetTopLevelFrameHWND(hwnd), ulDataOffset)) == NULL
|| !pCBZData->bFrameBorderEnabled )
{
return (FALSE);
}
if (pCBZData->sFrameBorderIndex >= pCBZData->sPushButtonIndex)
{
return (FALSE);
}
// alloc paint struct
if (DosAllocMem((PPVOID) & pFramePaint,
sizeof(TEMPPAINT),
PAG_READ | PAG_WRITE | PAG_COMMIT) != NO_ERROR)
{
return (FALSE);
}
memset(pFramePaint, 0, sizeof(TEMPPAINT));
pFramePaint->hab = WinQueryAnchorBlock(hwnd);
// alloc paint struct
if (DosAllocMem((PPVOID) & pPaint,
sizeof(PSPAINT),
PAG_READ | PAG_WRITE | PAG_COMMIT) != NO_ERROR)
{
DosFreeMem(pFramePaint);
return (FALSE);
}
memset(pPaint, 0, sizeof(PSPAINT));
//Text plugin needs this for quering presentation parameters.
pPaint->hwnd = hwnd;
// entire window
pPaint->rectlWindow = pPaint->rectlUpdate = *rect;
// get PS
pPaint->hpsWin = hpsFrame;
// we will blt and draw gradient text into the hps associated with this dc
if ((pFramePaint->hdc = DevOpenDC(pFramePaint->hab, OD_MEMORY, "*", 0L, (PDEVOPENDATA) NULL, NULLHANDLE))
== NULLHANDLE)
{
DosFreeMem(pPaint);
DosFreeMem(pFramePaint);
return (FALSE);
}
// create hps2 for hdc2. hps for hdc depends on size of bitmap, so it's not created until
// we know if it's active or not. create for size of window, then we blt only portion
// needed
pFramePaint->slHPS.cx = pPaint->rectlWindow.xRight;
pFramePaint->slHPS.cy = pPaint->rectlWindow.yTop;
if ((pPaint->hps = GpiCreatePS(pFramePaint->hab,
pFramePaint->hdc,
&(pFramePaint->slHPS),
PU_PELS | GPIF_DEFAULT | GPIT_MICRO | GPIA_ASSOC))
== NULLHANDLE)
{
DevCloseDC(pFramePaint->hdc);
DosFreeMem(pPaint);
DosFreeMem(pFramePaint);
return (FALSE);
}
pFramePaint->bif2.cbFix = sizeof(BITMAPINFOHEADER2);
pFramePaint->bif2.cx = pPaint->rectlWindow.xRight;
pFramePaint->bif2.cy = pPaint->rectlWindow.yTop;
pFramePaint->bif2.cBitCount = 24;
pFramePaint->bif2.cPlanes = 1;
if ((pFramePaint->hbmTemp = GpiCreateBitmap(pPaint->hps, // create bitmap
(PBITMAPINFOHEADER2) & (pFramePaint->bif2),
(ULONG) 0,
(PSZ) NULL,
(PBITMAPINFO2) & (pFramePaint->bif2))) == NULLHANDLE)
{
GpiDestroyPS(pPaint->hps);
DevCloseDC(pFramePaint->hdc);
DosFreeMem(pPaint);
DosFreeMem(pFramePaint);
return (FALSE);
}
if (GpiSetBitmap(pPaint->hps, pFramePaint->hbmTemp) == HBM_ERROR)
{
GpiDeleteBitmap(pFramePaint->hbmTemp);
GpiDestroyPS(pPaint->hps);
DevCloseDC(pFramePaint->hdc);
DosFreeMem(pPaint);
DosFreeMem(pFramePaint);
return (FALSE);
}
// set color table into rgb mode. otherwise colors between 0 and
// 15 are interpreted as indexes
GpiCreateLogColorTable(pPaint->hps, 0, LCOLF_RGB, 0, 0, NULL);
{
//fill ps with default bg color...
ULONG attrFound;
long lColor;
if ( (WinQueryPresParam(hwnd, PP_BACKGROUNDCOLOR, 0, &attrFound, sizeof(attrFound),
&lColor, QPF_PURERGBCOLOR)) == 0 )
lColor = WinQuerySysColor(HWND_DESKTOP, SYSCLR_DIALOGBACKGROUND, 0);
// fill with default color
WinFillRect(pPaint->hps, &(pPaint->rectlUpdate), lColor);
}
// call Plugins Paint Procedures here
for (i = pCBZData->sFrameBorderIndex; i < pCBZData->sPushButtonIndex; i++)
{
if ( !(pCBZData->Plugins[i].pfnPluginRender(pPaint, pCBZData->Plugins[i].pData, sState)) )
{
GpiSetBitmap(pPaint->hps, NULLHANDLE);
GpiDeleteBitmap(pFramePaint->hbmTemp);
GpiDestroyPS(pPaint->hps);
DevCloseDC(pFramePaint->hdc);
DosFreeMem(pPaint);
DosFreeMem(pFramePaint);
return (FALSE);
}
}
if ((rc = BltToWindow(pPaint)) == TRUE)
{
//paint sucessful, validate the window
// WinQueryWindowRect(hwnd, &(pPaint->rectlUpdate));
WinValidateRect(hwnd, &(pPaint->rectlUpdate), FALSE);
}
GpiSetBitmap(pPaint->hps, NULLHANDLE);
GpiDeleteBitmap(pFramePaint->hbmTemp);
GpiDestroyPS(pPaint->hps);
DevCloseDC(pFramePaint->hdc);
DosFreeMem(pPaint);
DosFreeMem(pFramePaint);
return (rc);
}
VOID InitProg(INT iArgc, PSZ rgArgv[])
{
APIRET rc;
BYTE szTranslate[256];
INT iArg;
ULONG ulLVB;
USHORT uscbLVB;
ULONG ulDataSize;
ULONG ulParmSize;
BOOL fSetParms = FALSE;
ULONG ulParm;
memset(szTranslate, 0, sizeof szTranslate);
/*
Determine if we run in the foreground
*/
rc = VioGetBuf(&ulLVB, &uscbLVB, (HVIO)0);
if (rc)
fForeGround = FALSE;
else
fForeGround = TRUE;
if (fForeGround)
printf("FAT32 cache helper version %s.\n", FAT32_VERSION);
else
WriteLogMessage("FAT32 task detached");
rc = DosGetNamedSharedMem((PVOID *)&pOptions, SHAREMEM, PAG_READ|PAG_WRITE);
if (!rc)
{
fActive = TRUE;
WriteLogMessage("Shared memory found!");
}
else
{
rc = DosAllocSharedMem((PVOID *)&pOptions, SHAREMEM, sizeof (LWOPTS), PAG_COMMIT|PAG_READ|PAG_WRITE);
if (rc)
DosExit(EXIT_PROCESS, 1);
memset(pOptions, 0, sizeof pOptions);
pOptions->bLWPrio = PRTYC_IDLETIME;
WriteLogMessage("Shared memory allocated!");
}
ulDataSize = sizeof f32Parms;
rc = DosFSCtl(
(PVOID)&f32Parms, ulDataSize, &ulDataSize,
NULL, 0, &ulParmSize,
FAT32_GETPARMS, "FAT32", -1, FSCTL_FSDNAME);
if (rc)
{
printf("DosFSCtl, FAT32_GETPARMS failed, rc = %d\n", rc);
DosExit(EXIT_PROCESS, 1);
}
if (strcmp(f32Parms.szVersion, FAT32_VERSION))
{
printf("ERROR: FAT32 version (%s) differs from CACHEF32 version (%s)\n", f32Parms.szVersion, FAT32_VERSION);
DosExit(EXIT_PROCESS, 1);
}
for (iArg = 1; iArg < iArgc; iArg++)
{
strupr(rgArgv[iArg]);
if (rgArgv[iArg][0] == '/' || rgArgv[iArg][0] == '-')
{
switch (rgArgv[iArg][1])
{
case '?' :
printf("USAGE: CACHEF32 [options]\n");
printf("/Q (Quit)\n");
printf("/N do NOT load lazy write deamon.\n");
printf("/D:diskidle in millisecs.\n");
printf("/B:bufferidle in millisecs.\n");
printf("/M:maxage in millisecs.\n");
printf("/R:d:,n sets read ahead sector count for drive d: to n.\n");
printf("/FS use short file names internally.\n");
printf("/FL use long file names internally.\n");
printf("/L:on|off set lazy writing on or off.\n");
printf("/P:1|2|3|4 Set priority of Lazy writer\n");
DosExit(EXIT_PROCESS, 0);
break;
case 'P':
if (rgArgv[iArg][2] != ':')
{
printf("Missing : after /P\n");
DosExit(EXIT_PROCESS, 1);
}
if (rgArgv[iArg][3] < '1' ||
rgArgv[iArg][3] > '4')
{
printf("Lazy write priority should be from 1 to 4!\n");
DosExit(EXIT_PROCESS, 1);
}
pOptions->bLWPrio = rgArgv[iArg][3] - '0';
break;
case 'N':
fLoadDeamon = FALSE;
break;
case 'T':
printf("The /T option is no longer supported.\n");
printf("Please read the documentation.\n");
break;
case 'Q' :
if (fActive)
{
if (pOptions->fTerminate)
printf("Terminate request already set!\n");
pOptions->fTerminate = TRUE;
printf("Terminating CACHEF32.EXE...\n");
DosExit(EXIT_PROCESS, 0);
}
printf("/Q is invalid, CACHEF32 is not running!\n");
DosExit(EXIT_PROCESS, 1);
break;
case 'D':
if (rgArgv[iArg][2] != ':')
{
printf("ERROR: missing : in %s\n", rgArgv[iArg]);
DosExit(EXIT_PROCESS, 1);
}
ulParm = atol(&rgArgv[iArg][3]);
if (!ulParm)
{
printf("ERROR: Invalid value in %s\n", rgArgv[iArg]);
DosExit(EXIT_PROCESS, 1);
}
f32Parms.ulDiskIdle = ulParm / TIME_FACTOR;
fSetParms = TRUE;
break;
case 'B':
if (rgArgv[iArg][2] != ':')
{
printf("ERROR: missing : in %s\n", rgArgv[iArg]);
DosExit(EXIT_PROCESS, 1);
}
ulParm = atol(&rgArgv[iArg][3]);
if (!ulParm)
{
printf("ERROR: Invalid value in %s\n", rgArgv[iArg]);
DosExit(EXIT_PROCESS, 1);
}
f32Parms.ulBufferIdle = ulParm / TIME_FACTOR;
fSetParms = TRUE;
break;
case 'M':
if (rgArgv[iArg][2] != ':')
{
printf("ERROR: missing : in %s\n", rgArgv[iArg]);
DosExit(EXIT_PROCESS, 1);
}
ulParm = atol(&rgArgv[iArg][3]);
if (!ulParm)
{
printf("ERROR: Invalid value in %s\n", rgArgv[iArg]);
DosExit(EXIT_PROCESS, 1);
}
f32Parms.ulMaxAge = ulParm / TIME_FACTOR;
fSetParms = TRUE;
break;
case 'R':
if (rgArgv[iArg][2] != ':')
{
printf("ERROR: missing : in %s\n", rgArgv[iArg]);
DosExit(EXIT_PROCESS, 1);
}
SetRASectors(&rgArgv[iArg][3]);
break;
case 'F':
if (rgArgv[iArg][2] == 'S')
f32Parms.fUseShortNames = TRUE;
else if (rgArgv[iArg][2] == 'L')
f32Parms.fUseShortNames = FALSE;
else
{
printf("ERROR: Unknown option %s\n", rgArgv[iArg]);
DosExit(EXIT_PROCESS, 1);
}
fSetParms = TRUE;
break;
case 'L':
if (!stricmp(&rgArgv[iArg][2], ":ON"))
{
rc = DosFSCtl(NULL, 0, NULL,
NULL, 0, NULL,
FAT32_STARTLW, "FAT32", -1, FSCTL_FSDNAME);
if (rc)
printf("Warning: Lazy writing is already active or cachesize is 0!\n");
}
else if (!stricmp(&rgArgv[iArg][2], ":OFF"))
{
rc = DosFSCtl(NULL, 0, NULL,
NULL, 0, NULL,
FAT32_STOPLW, "FAT32", -1, FSCTL_FSDNAME);
if (rc)
printf("Warning: Lazy writing is not active!\n");
}
else
{
printf("ERROR: Unknown option %s\n", rgArgv[iArg]);
DosExit(EXIT_PROCESS, 1);
}
break;
default :
printf("ERROR: Unknown option %s\n", rgArgv[iArg]);
DosExit(EXIT_PROCESS, 1);
break;
}
}
}
if (LoadTranslateTable())
fSetParms = TRUE;
if (fSetParms)
{
if (f32Parms.ulDiskIdle < f32Parms.ulBufferIdle)
{
printf("DISKIDLE must be greater than BUFFERIDLE\n");
DosExit(EXIT_PROCESS, 1);
}
ulParmSize = sizeof f32Parms;
rc = DosFSCtl(
NULL, 0, &ulDataSize,
(PVOID)&f32Parms, ulParmSize, &ulParmSize,
FAT32_SETPARMS, "FAT32", -1, FSCTL_FSDNAME);
if (rc)
{
printf("DosFSCtl FAT32_SETPARMS, failed, rc = %d\n", rc);
DosExit(EXIT_PROCESS, 1);
}
}
ulDriveMap = GetFAT32Drives();
if (!fActive)
{
if (!ulDriveMap)
{
printf("FAT32: No FAT32 partitions found, aborting...\n");
DosExit(EXIT_PROCESS, 1);
}
}
/*
Query parms
*/
if (fActive || !f32Parms.usCacheSize)
{
if (fActive)
{
printf("CACHEF32 is already running.\n");
printf("Current priority is %s.\n", rgPriority[pOptions->bLWPrio]);
}
if (!f32Parms.fLW)
printf("LAZY WRITING is NOT active!\n\n");
else
{
printf("\n");
printf("DISKIDLE : %lu milliseconds.\n", f32Parms.ulDiskIdle * TIME_FACTOR);
printf("BUFFERIDLE: %lu milliseconds.\n", f32Parms.ulBufferIdle * TIME_FACTOR);
printf("MAXAGE : %lu milliseconds.\n", f32Parms.ulMaxAge * TIME_FACTOR);
}
printf("\n");
ShowRASectors();
printf("\n");
printf("CACHE has space for %u sectors\n", f32Parms.usCacheSize);
printf("CACHE contains %u sectors\n", f32Parms.usCacheUsed);
printf("There are %u dirty sectors in cache.\n", f32Parms.usDirtySectors);
if (f32Parms.usPendingFlush > 0)
printf("%u sectors are in pending flush state.\n", f32Parms.usPendingFlush);
printf("The cache hits ratio is %3d%%.\n",
f32Parms.ulTotalHits * 100 / f32Parms.ulTotalReads);
if (f32Parms.fUseShortNames)
{
printf("Internally, short names are used.\n");
printf("All files are visible in DOS sessions.\n");
}
else
{
printf("Internally, long names are used.\n");
printf("Files and directories with long names are hidden for DOS.\n");
}
printf("FAT32.IFS has currently %u GDT segments allocated.\n",
f32Parms.usSegmentsAllocated);
}
return;
}
//called to allocate memory and setup initial settings
BOOL CBZInit(HINI hIni, char szName[], char szClass[], PVOID * pData)
{
PLUGINSHARE *pPluginShare;
PLUGINSHARE *pPluginData;
char szReadName[64];
char szShareName[64];
ULONG szData;
// alloc window words for the plugin's data
if ((DosAllocMem((PPVOID) (pData),
sizeof(PLUGINSHARE),
PAG_READ | PAG_WRITE | PAG_COMMIT)) != NO_ERROR)
{
return FALSE;
}
//initialize the plugin's data to zeros.
memset(*pData, 0, sizeof(PLUGINSHARE));
pPluginData = (PLUGINSHARE *) * pData;
strcpy(szShareName, PLUGIN_SHARE);
strcat(szShareName, szClass);
//custom name was specified, try to load the custom config for it.
if (strlen(szName) > 0)
{
strcpy(szReadName, szName);
strcat(szReadName, "_");
strcat(szReadName, szClass);
strcat(szReadName, "_CBZLINESPlugin");
szData = sizeof(PLUGINSHARE);
// get shared mem
if (!PrfQueryProfileData(hIni,
"CustomOptionsData",
szReadName,
pPluginData,
&szData))
{
// if shared mem is not available, use defaults!
if (DosGetNamedSharedMem((PPVOID) & pPluginData, szShareName, PAG_READ) != NO_ERROR)
{
//use some defaults?
pPluginData->lActiveLineColor = 121 * 65536 + 127;
pPluginData->lActiveShadowColor = 255 * (65536 + 1);
pPluginData->lInactiveLineColor = 100 * (65536 + 256 + 1);
pPluginData->lInactiveShadowColor = 204 * (65536 + 256 + 1);
pPluginData->bActiveEnabled = TRUE;
pPluginData->bInactiveEnabled = TRUE;
pPluginData->lLineStyle = 7;
if (!PrfWriteProfileData(hIni,
"CustomOptionsData",
szReadName,
pPluginData,
sizeof(PLUGINSHARE)))
{
//not a fatal error
}
}
}
} //end if (szName > 0)
else
{
//Load defaults! No custom name specified.
// if shared mem is not available, try allocating it!
if (DosGetNamedSharedMem((PPVOID) & pPluginShare, szShareName, PAG_READ) != NO_ERROR)
{
//try Allocating the SharedMem space for this plugin!
if (DosAllocSharedMem((PPVOID) & pPluginShare,
szShareName,
sizeof(PLUGINSHARE),
PAG_READ | PAG_WRITE | PAG_COMMIT) != NO_ERROR)
return (FALSE); //ignore this plugin... It must be broken?
// clear it
memset(pPluginShare, 0, sizeof(PLUGINSHARE));
szData = sizeof(PLUGINSHARE);
// get shared mem
strcpy(szReadName, szClass);
strcat(szReadName, "_CBZLINESPlugin");
if (!PrfQueryProfileData(hIni,
"UserOptionsData",
szReadName,
pPluginShare,
&szData))
{
pPluginShare->lActiveLineColor = 121 * 65536 + 127;
pPluginShare->lActiveShadowColor = 255 * (65536 + 1);
pPluginShare->lInactiveLineColor = 100 * (65536 + 256 + 1);
pPluginShare->lInactiveShadowColor = 204 * (65536 + 256 + 1);
pPluginShare->bActiveEnabled = TRUE;
pPluginShare->bInactiveEnabled = TRUE;
pPluginShare->lLineStyle = 7;
if (!PrfWriteProfileData(hIni,
"UserOptionsData",
szReadName,
pPluginShare,
sizeof(PLUGINSHARE)))
{
//not a fatal error.
}
}
} //end if
//copy from shared memory to each windows window words.
pPluginData->lActiveLineColor = pPluginShare->lActiveLineColor;
pPluginData->lActiveShadowColor = pPluginShare->lActiveShadowColor;
pPluginData->lInactiveLineColor = pPluginShare->lInactiveLineColor;
pPluginData->lInactiveShadowColor = pPluginShare->lInactiveShadowColor;
pPluginData->bActiveEnabled = pPluginShare->bActiveEnabled;
pPluginData->bInactiveEnabled = pPluginShare->bInactiveEnabled;
pPluginData->lLineStyle = pPluginShare->lLineStyle;
} //end else
return TRUE;
}
//change current settings.
BOOL CBZApply(char szClass[], KEY_VALUE * kv, int count, int enabledState, PVOID pData)
{
int i;
PLUGINSHARE *pPluginShare;
char szShareName[32];
char szSaveName[32];
BOOL bDefaultApply = FALSE;
pPluginShare = (PLUGINSHARE *) pData;
//if null, this is a default apply, so load shared memory.
if (pPluginShare == NULL)
{
strcpy(szShareName, PLUGIN_SHARE);
strcat(szShareName, szClass);
// if shared mem is not available, try allocating temporary space!
if (DosGetNamedSharedMem((PPVOID) & pPluginShare, szShareName, PAG_READ | PAG_WRITE) != NO_ERROR)
{
return FALSE;
}
bDefaultApply = TRUE;
}
if ((enabledState == 0) || (enabledState == 2))
pPluginShare->bActiveEnabled = TRUE;
else
pPluginShare->bActiveEnabled = FALSE;
if ((enabledState == 1) || (enabledState == 2))
pPluginShare->bInactiveEnabled = TRUE;
else
pPluginShare->bInactiveEnabled = FALSE;
//loop through each key/value pair and set appropriate parameters
for (i = 0; i < count; i++)
{
if (pPluginShare->bActiveEnabled)
{
if (strcmp(kv[i].key, "ActiveLineColor") == 0)
{
//StringToLong() returns 0L on error...which is as good as any value for an error condition?
pPluginShare->lActiveLineColor = StringToLong(kv[i].value);
}
else if (strcmp(kv[i].key, "ActiveShadowColor") == 0)
{
pPluginShare->lActiveShadowColor = StringToLong(kv[i].value);
}
} //end bInactive if condition
if (pPluginShare->bInactiveEnabled)
{
if (strcmp(kv[i].key, "InactiveLineColor") == 0)
{
//StringToLong() returns 0L on error...which is as good as any value for an error condition?
pPluginShare->lInactiveLineColor = StringToLong(kv[i].value);
}
else if (strcmp(kv[i].key, "InactiveShadowColor") == 0)
{
pPluginShare->lInactiveShadowColor = StringToLong(kv[i].value);
}
} //end bInactive if condition
if (strcmp(kv[i].key, "LineStyle") == 0)
{
//StringToLong() returns 0L on error...which is as good as any value for an error condition?
pPluginShare->lLineStyle = StringToLong(kv[i].value);
}
} //end for loop
if (bDefaultApply)
DosFreeMem(pPluginShare);
return TRUE;
}
int ap_mpm_run(apr_pool_t *_pconf, apr_pool_t *plog, server_rec *s )
{
char *listener_shm_name;
parent_info_t *parent_info;
ULONG rc;
pconf = _pconf;
ap_server_conf = s;
restart_pending = 0;
DosSetMaxFH(ap_thread_limit * 2);
listener_shm_name = apr_psprintf(pconf, "/sharemem/httpd/parent_info.%d", getppid());
rc = DosGetNamedSharedMem((PPVOID)&parent_info, listener_shm_name, PAG_READ);
is_parent_process = rc != 0;
ap_scoreboard_fname = apr_psprintf(pconf, "/sharemem/httpd/scoreboard.%d", is_parent_process ? getpid() : getppid());
if (rc == 0) {
/* Child process */
ap_listen_rec *lr;
int num_listeners = 0;
ap_mpm_accept_mutex = parent_info->accept_mutex;
/* Set up a default listener if necessary */
if (ap_listeners == NULL) {
ap_listen_rec *lr = apr_pcalloc(s->process->pool, sizeof(ap_listen_rec));
ap_listeners = lr;
apr_sockaddr_info_get(&lr->bind_addr, "0.0.0.0", APR_UNSPEC,
DEFAULT_HTTP_PORT, 0, s->process->pool);
apr_socket_create(&lr->sd, lr->bind_addr->family,
SOCK_STREAM, s->process->pool);
}
for (lr = ap_listeners; lr; lr = lr->next) {
apr_sockaddr_t *sa;
apr_os_sock_put(&lr->sd, &parent_info->listeners[num_listeners].listen_fd, pconf);
apr_socket_addr_get(&sa, APR_LOCAL, lr->sd);
num_listeners++;
}
DosFreeMem(parent_info);
/* Do the work */
ap_mpm_child_main(pconf);
/* Outta here */
return 1;
}
else {
/* Parent process */
char restart;
is_parent_process = TRUE;
if (ap_setup_listeners(ap_server_conf) < 1) {
ap_log_error(APLOG_MARK, APLOG_ALERT, 0, s,
"no listening sockets available, shutting down");
return 1;
}
ap_log_pid(pconf, ap_pid_fname);
restart = master_main();
++ap_my_generation;
ap_scoreboard_image->global->running_generation = ap_my_generation;
if (!restart) {
const char *pidfile = ap_server_root_relative(pconf, ap_pid_fname);
if (pidfile != NULL && remove(pidfile) == 0) {
ap_log_error(APLOG_MARK, APLOG_INFO, APR_SUCCESS,
ap_server_conf, "removed PID file %s (pid=%d)",
pidfile, getpid());
}
ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, ap_server_conf,
"caught SIGTERM, shutting down");
return 1;
}
} /* Parent process */
return 0; /* Restart */
}
