1 line
54 KiB
C
Executable File
1 line
54 KiB
C
Executable File
/* Copyright (c) 2017, Computer History Museum
|
||
All rights reserved.
|
||
Redistribution and use in source and binary forms, with or without modification, are permitted (subject to
|
||
the limitations in the disclaimer below) provided that the following conditions are met:
|
||
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
|
||
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
|
||
disclaimer in the documentation and/or other materials provided with the distribution.
|
||
* Neither the name of Computer History Museum nor the names of its contributors may be used to endorse or promote products
|
||
derived from this software without specific prior written permission.
|
||
NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE
|
||
COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
|
||
DAMAGE. */
|
||
|
||
/*
|
||
File: Threading.c
|
||
Author: Clarence Wong <cwong@qualcomm.com>
|
||
Date: February 1997 - ...
|
||
Copyright (c) 1997 by QUALCOMM Incorporated
|
||
|
||
Comments:
|
||
|
||
- To switch threading off, #undef THREADING_ON in PreCompTwoPPC.pch
|
||
- Threads can access all global variables (globals have inter-thread global scope by default)
|
||
- Threads can also maintain "intra-thread global" variables via context switch procs.
|
||
(the scope of the variable is global to one specific thread.)
|
||
Check out the threadContextData and threadGlobals structs to see the intra-thread globals
|
||
- Do not unload code segments that are referenced in the calling chain of any running or stopped thread
|
||
- Out-Context switch procs must be manually called from the thread termination proc
|
||
|
||
-- SEE END OF FILE FOR DESIGN OVERVIEW --
|
||
-- SEE END OF FILE FOR BUG LIST --
|
||
*/
|
||
|
||
#define FILE_NUM 90
|
||
|
||
#ifdef THREADING_ON
|
||
|
||
#define THREAD_STACK_SIZE (HaveOSX() ? 0 : 64 K)
|
||
|
||
#if __profile__
|
||
#include <Profiler.h>
|
||
#endif
|
||
|
||
// #define DEBUG_THREAD
|
||
|
||
#include "threading.h"
|
||
#pragma segment Threads
|
||
|
||
/*
|
||
private data structures
|
||
*/
|
||
|
||
typedef struct prefChange_ {
|
||
short pref;
|
||
uLong persId;
|
||
} prefChangeRec, *prefChangePtr;
|
||
|
||
short gNumBackgroundThreads = 0;
|
||
static ThreadID gMainThreadID = 0;
|
||
static short gCriticalSection = 0;
|
||
|
||
/*
|
||
private functions
|
||
*/
|
||
static OSErr CopySettingsForThread (short sourceRefN, PersHandle sourcePerslist, short *destRefN, PersHandle *destPersList, PersHandle *destCurPers);
|
||
static OSErr DeleteSettingsForThread (short *settingsRefN);
|
||
static OSErr SaveSettingsToMainThread (threadDataHandle threadData);
|
||
static OSErr InitThreadGlobals (threadGlobalsPtr *newThreadGlobals);
|
||
static OSErr DisposeThreadGlobals (threadGlobalsPtr threadGlobals);
|
||
|
||
int GetFCCs(MessHandle messH, CSpecHandle fccSpecs); // move to sendmail.c?
|
||
|
||
#ifdef IMAP
|
||
static OSErr NewXferMail(threadDataHandle *tData, Boolean check, Boolean send, Boolean manual,Boolean ae,XferFlags flags,IMAPTransferPtr imapInfo);
|
||
#else
|
||
static OSErr NewXferMail(threadDataHandle *tData, Boolean check, Boolean send, Boolean manual,Boolean ae,XferFlags flags);
|
||
#endif
|
||
pascal void *XferMailThread (void *threadParameter);
|
||
pascal void ThreadSwitchProcIn (ThreadID threadBeingSwitched, void *switchProcParam);
|
||
pascal void ThreadSwitchProcOut (ThreadID threadBeingSwitched, void *switchProcParam);
|
||
pascal void ThreadTermination (ThreadID threadTerminated, void *terminationProcParam);
|
||
|
||
|
||
#ifdef TASK_PROGRESS_ON
|
||
#ifdef DEBUG
|
||
void InvalTaskProgressBeat(ProgressBHandle prbl);
|
||
#endif
|
||
#endif
|
||
|
||
void CheckSelectedGlobals ();
|
||
|
||
#ifdef DEBUG_THREAD
|
||
static pascal void MyDebuggerNewThread(ThreadID threadCreated);
|
||
static pascal void MyDebuggerDisposeThread(ThreadID threadDeleted);
|
||
static pascal ThreadID MyDebuggerThreadScheduler (SchedulerInfoRecPtr schedulerInfo);
|
||
|
||
|
||
/* This guy isn't getting called!!!! */
|
||
|
||
static pascal void MyDebuggerNewThread(ThreadID threadCreated)
|
||
{
|
||
DebugStr ("\pThread started");
|
||
}
|
||
|
||
/* This guy isn't getting called!!!! */
|
||
|
||
static pascal void MyDebuggerDisposeThread(ThreadID threadDeleted)
|
||
{
|
||
DebugStr ("\pThread ended");
|
||
}
|
||
|
||
static pascal ThreadID MyDebuggerThreadScheduler (SchedulerInfoRecPtr schedulerInfo)
|
||
{
|
||
Str255 text;
|
||
|
||
ComposeString(text,"\pContext Switch -- tickCount:%d curThread:%d", TickCount(), (int) schedulerInfo->CurrentThreadID);
|
||
DebugStr (text);
|
||
|
||
return (kNoThreadID);
|
||
}
|
||
#endif
|
||
|
||
|
||
/************************************************************************
|
||
* GetThreadData -
|
||
************************************************************************/
|
||
void GetThreadData (ThreadID threadID, threadDataHandle *threadData)
|
||
{
|
||
threadDataHandle index;
|
||
|
||
*threadData = nil;
|
||
for (index=gThreadData;index;index=(*index)->next)
|
||
if ((*index)->threadID==threadID)
|
||
{
|
||
*threadData = index;
|
||
return;
|
||
}
|
||
}
|
||
|
||
/************************************************************************
|
||
* GetCurrentThreadData -
|
||
************************************************************************/
|
||
void GetCurrentThreadData (threadDataHandle *threadData)
|
||
{
|
||
ThreadID threadID;
|
||
OSErr err;
|
||
|
||
if (ThreadsAvailable() && !(err = GetCurrentThread (&threadID)))
|
||
GetThreadData(threadID,threadData);
|
||
else
|
||
*threadData = nil;
|
||
ASSERT(!err);
|
||
}
|
||
|
||
/************************************************************************
|
||
* GetCurrentThreadPrbl -
|
||
************************************************************************/
|
||
ProgressBlock **GetCurrentThreadPrbl(void)
|
||
{
|
||
threadDataHandle threadData = nil;
|
||
|
||
GetCurrentThreadData (&threadData);
|
||
return (threadData ? (*threadData)->prbl : nil);
|
||
}
|
||
|
||
|
||
#pragma segment newthreads
|
||
|
||
/*
|
||
put functions that create threads in a separate segment:
|
||
they can safely be unloaded from the main event loop (provided they don't Yield to other threads)
|
||
they should be in a separate segment from referenced procptrs (to ensure that procptrs are A5-relative)
|
||
*/
|
||
|
||
/************************************************************************
|
||
* InitThreadGlobals - create thread and allocate data for it
|
||
************************************************************************/
|
||
static OSErr InitThreadGlobals (threadGlobalsPtr *newThreadGlobals)
|
||
{
|
||
if (!(*newThreadGlobals = (threadGlobalsPtr) NuPtrClear (sizeof (**newThreadGlobals))))
|
||
return (MemError ());
|
||
(*newThreadGlobals)->tSettingsRefN = -1;
|
||
(*newThreadGlobals)->tResRefN = -1;
|
||
(*newThreadGlobals)->tCurTrans = CurTrans;
|
||
return (noErr);
|
||
}
|
||
|
||
|
||
/************************************************************************
|
||
* CopyOutToTemp - copy queued messages in Out mailbox to temporary Out mailbox
|
||
************************************************************************/
|
||
static OSErr CopyOutToTemp (void)
|
||
{
|
||
int ii;
|
||
TOCHandle tocH,
|
||
tempTocH;
|
||
StateEnum state;
|
||
MessHandle messH;
|
||
OSErr err = noErr;
|
||
uLong gmtSecs = GMTDateTime();
|
||
PersHandle pers;
|
||
|
||
MyThreadBeginCritical();
|
||
SetMyCursor(watchCursor);
|
||
tocH = GetRealOutTOC ();
|
||
tempTocH = GetTempOutTOC ();
|
||
|
||
TotalQueuedSize = 0;
|
||
if (tocH && tempTocH)
|
||
{
|
||
// only copy messages ready to be sent now
|
||
for (ii = 0; ii < (*tocH)->count; ii++)
|
||
if (!(*tocH)->sums[ii].messH && IsQueued(tocH,ii))
|
||
{
|
||
pers = FindPersById((*tocH)->sums[ii].persId);
|
||
ASSERT(pers);
|
||
if (pers && (*pers)->sendMeNow && (*tocH)->sums[ii].seconds<=gmtSecs)
|
||
{
|
||
/*
|
||
* handle open, dirty windows
|
||
*/
|
||
if (messH = SaveB4Send(tocH,ii))
|
||
{
|
||
MiniEvents(); // in case we're hogging time
|
||
TotalQueuedSize+=(ApproxMessageSize(messH) K);
|
||
state = (*tocH)->sums[ii].state;
|
||
err = MoveMessageLo (tocH, ii, &(*tempTocH)->mailbox.spec, true, true, true);
|
||
if (err) break;
|
||
SetState(tocH, ii, BUSY_SENDING);
|
||
SetState(tempTocH,(*tempTocH)->count - 1,state);
|
||
if ((*messH)->win)
|
||
CloseMyWindow(GetMyWindowWindowPtr((*messH)->win));
|
||
}
|
||
}
|
||
BoxFClose(tempTocH,true);
|
||
}
|
||
WriteTOC(tempTocH);
|
||
}
|
||
MyThreadEndCritical();
|
||
return(err);
|
||
}
|
||
|
||
|
||
/************************************************************************
|
||
* NewXferMail - create thread and allocate data for it
|
||
************************************************************************/
|
||
#ifdef IMAP
|
||
static OSErr NewXferMail(threadDataHandle *tData, Boolean check, Boolean send, Boolean manual,Boolean ae,XferFlags flags,IMAPTransferPtr imapInfo)
|
||
#else
|
||
static OSErr NewXferMail(threadDataHandle *tData, Boolean check, Boolean send, Boolean manual,Boolean ae,XferFlags flags)
|
||
#endif
|
||
{
|
||
threadDataHandle threadData = nil;
|
||
threadContextDataPtr threadContext = nil;
|
||
ThreadID threadID;
|
||
OSErr theError = noErr;
|
||
threadGlobalsPtr newThreadGlobals = nil;
|
||
DECLARE_UPP(XferMailThread,ThreadEntry);
|
||
DECLARE_UPP(ThreadSwitchProcIn,ThreadSwitch);
|
||
DECLARE_UPP(ThreadSwitchProcOut,ThreadSwitch);
|
||
DECLARE_UPP(ThreadTermination,ThreadTermination);
|
||
|
||
ASSERT (ThreadsAvailable());
|
||
|
||
// Don't allow more than one checkmail or sendmail thread
|
||
if ((CheckThreadRunning && check) || (SendThreadRunning && send))
|
||
{
|
||
ASSERT(0);
|
||
*tData = nil;
|
||
return threadTooManyReqsErr;
|
||
}
|
||
|
||
SendThreadRunning = SendThreadRunning || send;
|
||
CheckThreadRunning = CheckThreadRunning || check;
|
||
if (CheckThreadRunning)
|
||
TaskProgressRefresh();
|
||
|
||
IncrementNumBackgroundThreads ();
|
||
|
||
// set up threadContext
|
||
if (!(threadData = (threadDataHandle) NuHandleClear (sizeof (**threadData))))
|
||
theError = MemError ();
|
||
if (threadData)
|
||
(*threadData)->next = gThreadData;
|
||
gThreadData = threadData;
|
||
if (!theError)
|
||
theError = InitThreadGlobals (&newThreadGlobals);
|
||
if (!theError)
|
||
{
|
||
threadContext = &(*threadData)->threadContext;
|
||
#if !TARGET_RT_MAC_CFM
|
||
threadContext->appsA5 = SetCurrentA5 ();
|
||
#endif
|
||
threadContext->newThreadGlobals = newThreadGlobals;
|
||
|
||
HLock((Handle)threadData);
|
||
theError = StackInit(sizeof (prefChangeRec),&threadContext->prefStack);
|
||
HUnlock((Handle)threadData);
|
||
}
|
||
if (!theError)
|
||
{
|
||
#ifdef TASK_PROGRESS_ON
|
||
if (!((*threadData)->prbl = NewZH(ProgressBlock)))
|
||
theError = MemError();
|
||
#endif
|
||
(*threadData)->xferMailParams.send = send;
|
||
(*threadData)->xferMailParams.check = check;
|
||
(*threadData)->xferMailParams.manual = manual;
|
||
(*threadData)->xferMailParams.ae = ae;
|
||
BlockMoveData (&flags, &(*threadData)->xferMailParams.flags, sizeof ((*threadData)->xferMailParams.flags));
|
||
#ifdef IMAP
|
||
(*threadData)->imapInfo.command = UndefinedTask;
|
||
if (imapInfo) BlockMoveData(imapInfo,&((*threadData)->imapInfo),sizeof(IMAPTransferRec));
|
||
#endif
|
||
}
|
||
if (!theError)
|
||
theError = CopySettingsForThread (ThreadGlobals.tSettingsRefN, ThreadGlobals.tPersList, &newThreadGlobals->tSettingsRefN, &newThreadGlobals->tPersList, &newThreadGlobals->tCurPers);
|
||
|
||
// if send only, use smaller stack size????
|
||
MemCanFail = true;
|
||
INIT_UPP(XferMailThread,ThreadEntry);
|
||
INIT_UPP(ThreadSwitchProcIn,ThreadSwitch);
|
||
INIT_UPP(ThreadSwitchProcOut,ThreadSwitch);
|
||
INIT_UPP(ThreadTermination,ThreadTermination);
|
||
if (!theError)
|
||
theError = NewThread (kCooperativeThread, XferMailThreadUPP, (void *) threadData, THREAD_STACK_SIZE, kCreateIfNeeded + kNewSuspend, 0L, &threadID);
|
||
MemCanFail = false;
|
||
if (!theError)
|
||
theError = SetThreadSwitcher (threadID, ThreadSwitchProcInUPP, (void *) threadData, true);
|
||
if (!theError)
|
||
theError = SetThreadSwitcher (threadID, ThreadSwitchProcOutUPP, (void *) threadData, false);
|
||
if (!theError)
|
||
theError = SetThreadTerminator (threadID, ThreadTerminationUPP, (void *) threadData);
|
||
|
||
if (!theError)
|
||
(*threadData)->threadID = threadID;
|
||
#if __profile__
|
||
if (!theError)
|
||
{
|
||
Size stackSize;
|
||
ProfilerThreadRef threadRef;
|
||
|
||
GetDefaultThreadStackSize(kCooperativeThread,&stackSize);
|
||
theError = ProfilerCreateThread(100,stackSize,&threadRef);
|
||
(*threadData)->threadRef = threadRef;
|
||
ASSERT(!theError);
|
||
}
|
||
#endif
|
||
if (!theError)
|
||
theError = SetThreadState (threadID, kReadyThreadState, kNoThreadID);
|
||
#ifdef TASK_PROGRESS_ON
|
||
if (TaskProgressWindow && gTaskProgressInitied)
|
||
{
|
||
if (!theError && threadData)
|
||
AddProgressTask(threadData);
|
||
else
|
||
InvalContent(TaskProgressWindow);
|
||
}
|
||
#endif
|
||
if (theError)
|
||
{
|
||
if (send)
|
||
SendThreadRunning = false;
|
||
if (check)
|
||
CheckThreadRunning = false;
|
||
DecrementNumBackgroundThreads ();
|
||
if (threadData)
|
||
{
|
||
#ifdef TASK_PROGRESS_ON
|
||
if ((*threadData)->stopButton)
|
||
DisposeControl((*threadData)->stopButton);
|
||
ASSERT((*threadData)->prbl);
|
||
DisposProgress((*threadData)->prbl);
|
||
#endif
|
||
LL_Remove(gThreadData,threadData,(threadDataHandle));
|
||
DisposeThreadGlobals (newThreadGlobals);
|
||
DisposeHandle ((Handle)threadData);
|
||
threadData = nil;
|
||
}
|
||
if (!manual)
|
||
ResetCheckTime(True);
|
||
CheckOnIdle = false;
|
||
}
|
||
*tData = threadData;
|
||
return (CommandPeriod ? userCanceledErr : theError);
|
||
}
|
||
|
||
|
||
/************************************************************************
|
||
* SetupXferMailThread - create thread and allocate data for it
|
||
************************************************************************/
|
||
#ifdef IMAP
|
||
OSErr SetupXferMailThread (Boolean check, Boolean send, Boolean manual,Boolean ae,XferFlags flags,IMAPTransferPtr imapInfo)
|
||
#else
|
||
OSErr SetupXferMailThread (Boolean check, Boolean send, Boolean manual,Boolean ae,XferFlags flags)
|
||
#endif
|
||
{
|
||
threadDataHandle sendData = nil,
|
||
checkData = nil;
|
||
OSErr err = noErr;
|
||
|
||
// we tried to send it
|
||
if (send)
|
||
SendImmediately = False;
|
||
if (PrefIsSet(PREF_THREADING_SEND_OFF) || PrefIsSet(PREF_POP_SEND) || !(check && send))
|
||
{
|
||
#ifdef IMAP
|
||
err = NewXferMail(&checkData,check,send,manual,ae,flags,imapInfo);
|
||
#else
|
||
err = NewXferMail(&checkData,check,send,manual,ae,flags);
|
||
#endif
|
||
sendData = checkData;
|
||
}
|
||
else
|
||
{
|
||
#ifdef IMAP
|
||
if (!(err = NewXferMail(&checkData,check,false,manual,ae,flags,imapInfo)))
|
||
{
|
||
if (NewXferMail(&sendData,false,send,manual,ae,flags,imapInfo))
|
||
#else
|
||
if (!(err = NewXferMail(&checkData,check,false,manual,ae,flags)))
|
||
{
|
||
if (NewXferMail(&sendData,false,send,manual,ae,flags))
|
||
#endif
|
||
{
|
||
if (!SendThreadRunning)
|
||
{
|
||
ASSERT(checkData);
|
||
if (checkData)
|
||
{
|
||
(*checkData)->xferMailParams.send = send;
|
||
sendData = checkData;
|
||
SendThreadRunning = send;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
#ifdef TASK_PROGRESS_ON
|
||
#ifndef BATCH_DELIVERY_ON
|
||
if (!err && check && checkData && TaskProgressWindow && NeedToFilterIn)
|
||
RemoveFilterTask();
|
||
#endif
|
||
#endif
|
||
if (err!=userCanceledErr)
|
||
{
|
||
if (check && !checkData)
|
||
WarnUser(THREAD_CANT_CHECK,err);
|
||
else
|
||
if (send && !sendData)
|
||
WarnUser(THREAD_CANT_SEND,err);
|
||
if (!err && send && sendData)
|
||
{
|
||
if (err = CopyOutToTemp())
|
||
WarnUser(THREAD_CANT_SEND_ALL,err);
|
||
}
|
||
}
|
||
return err;
|
||
}
|
||
|
||
|
||
#pragma segment Threads
|
||
|
||
/************************************************************************
|
||
* DisposeThreadGlobals -
|
||
************************************************************************/
|
||
static OSErr DisposeThreadGlobals (threadGlobalsPtr threadGlobals)
|
||
{
|
||
if (!threadGlobals)
|
||
return paramErr;
|
||
|
||
CurThreadGlobals = threadGlobals;
|
||
// kill string cache
|
||
if (StringCache)
|
||
{
|
||
DisposeHandle ((Handle) StringCache);
|
||
StringCache = nil;
|
||
}
|
||
|
||
/* Kill personalities */
|
||
DisposePersonalities ();
|
||
PersList = nil;
|
||
CurPers = nil;
|
||
if (PersStack)
|
||
{
|
||
DisposeHandle ((Handle) PersStack);
|
||
PersStack = nil;
|
||
}
|
||
|
||
// MIME Maps
|
||
ZapHandle(MMIn);
|
||
ZapHandle(MMOut);
|
||
|
||
if (GWStack)
|
||
{
|
||
DisposeHandle ((Handle) GWStack);
|
||
GWStack = nil;
|
||
}
|
||
DisposePtr ((Ptr)threadGlobals);
|
||
threadGlobals = nil;
|
||
CurThreadGlobals = &ThreadGlobals;
|
||
return (noErr);
|
||
}
|
||
|
||
|
||
/************************************************************************
|
||
* CleanTempOutTOC - now that we update mesg status immediately and
|
||
* user can move these unlocked messages, we can
|
||
* just clear temp out box
|
||
************************************************************************/
|
||
void CleanTempOutTOC (void)
|
||
{
|
||
TOCHandle tempTocH;
|
||
short ii;
|
||
uLong oldForceSend = ForceSend;
|
||
|
||
tempTocH = GetTempOutTOC ();
|
||
ASSERT (tempTocH);
|
||
// maybe there's a quicker way???
|
||
if (tempTocH)
|
||
for (ii = 0; ii < (*tempTocH)->count; ii++)
|
||
if (!DeleteSum (tempTocH, ii))
|
||
ii--;
|
||
ForceSend = oldForceSend;
|
||
}
|
||
|
||
|
||
/************************************************************************
|
||
* CleanRealOutTOC -
|
||
************************************************************************/
|
||
void CleanRealOutTOC (void)
|
||
{
|
||
TOCHandle tocH = GetRealOutTOC (),
|
||
tempTocH = GetTempOutTOC();
|
||
int ii;
|
||
short sum;
|
||
|
||
if (!(tocH && tempTocH))
|
||
return;
|
||
|
||
for (ii=(*tocH)->count-1; ii>=0; ii--)
|
||
{
|
||
if ((*tocH)->sums[ii].state == BUSY_SENDING)
|
||
{
|
||
sum = FindSumByHash (tempTocH,(*tocH)->sums[ii].uidHash);
|
||
SetState(tocH,ii,(sum!=-1) ? (*tempTocH)->sums[sum].state : SENDABLE);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/************************************************************************
|
||
* GetCurrentTaskKind -
|
||
************************************************************************/
|
||
TaskKindEnum GetCurrentTaskKind(void)
|
||
{
|
||
threadDataHandle threadData = nil;
|
||
|
||
GetCurrentThreadData (&threadData);
|
||
return(threadData ? (*threadData)->currentTask : UndefinedTask);
|
||
}
|
||
|
||
/************************************************************************
|
||
* SetCurrentTaskKind -
|
||
************************************************************************/
|
||
void SetCurrentTaskKind(TaskKindEnum taskKind)
|
||
{
|
||
threadDataHandle threadData = nil;
|
||
|
||
GetCurrentThreadData (&threadData);
|
||
if (threadData)
|
||
(*threadData)->currentTask = taskKind;
|
||
}
|
||
|
||
/************************************************************************
|
||
* killThreads - cancel each thread and wait until they're all dead
|
||
************************************************************************/
|
||
void KillThreads (void)
|
||
{
|
||
threadDataHandle threadDataIndex;
|
||
// cancel each thread
|
||
for (threadDataIndex=gThreadData;threadDataIndex;threadDataIndex=(*threadDataIndex)->next)
|
||
SetThreadGlobalCommandPeriod ((*threadDataIndex)->threadID,true);
|
||
|
||
#ifndef VALPHA
|
||
// what if a thread is asleep or just too dumb to die?
|
||
// i don't currently put them to sleep, but i may in the future.
|
||
// so i better check to see if thread is asleep...
|
||
// and maybe i should timeout if this takes too long?
|
||
#endif
|
||
while (GetNumBackgroundThreads ())
|
||
MyYieldToAnyThread ();
|
||
}
|
||
|
||
/************************************************************************
|
||
* XferMailThread - open threaded progress, xfermail, save
|
||
* and delete settings
|
||
************************************************************************/
|
||
pascal void *XferMailThread (void *threadParameter)
|
||
{
|
||
threadDataHandle threadData = nil;
|
||
OSErr theError = noErr;
|
||
xferMailParamsRec xferMailParams;
|
||
#ifdef IMAP
|
||
IMAPTransferRec imapInfo;
|
||
#endif
|
||
|
||
ASSERT (threadParameter);
|
||
if (!threadParameter)
|
||
return nil;
|
||
|
||
threadData = (threadDataHandle) threadParameter;
|
||
#ifdef DEBUG
|
||
(*threadData)->startTime = TickCount();
|
||
#endif
|
||
BlockMoveData (&(*threadData)->xferMailParams, &xferMailParams, sizeof (xferMailParams));
|
||
#ifdef IMAP
|
||
BlockMoveData(&(*threadData)->imapInfo, &imapInfo, sizeof(IMAPTransferRec));
|
||
#endif
|
||
#ifdef DEBUG_THREAD
|
||
MyDebuggerNewThread((*threadData)->threadContext.threadID);
|
||
#endif
|
||
if (!theError)
|
||
{
|
||
#ifndef BATCH_DELIVERY_ON
|
||
if (xferMailParams.manual)
|
||
{
|
||
short idleCount = GetRLong(MODAL_IDLE_SECS)*60;
|
||
if (!NeedToFilterIn && !NeedToFilterOut)
|
||
ActiveTicks = (ActiveTicks > idleCount) ? (ActiveTicks - idleCount) : 0;
|
||
}
|
||
#endif
|
||
#ifdef IMAP
|
||
theError=XferMailRun (xferMailParams.check, xferMailParams.send, xferMailParams.manual, xferMailParams.ae,xferMailParams.flags,&imapInfo);
|
||
#else
|
||
theError=XferMailRun (xferMailParams.check, xferMailParams.send, xferMailParams.manual, xferMailParams.ae,xferMailParams.flags);
|
||
#endif
|
||
CloseProgress ();
|
||
SaveSettingsToMainThread (threadData);
|
||
DeleteSettingsForThread (&SettingsRefN);
|
||
}
|
||
if (xferMailParams.send)
|
||
{
|
||
if (CommandPeriod || theError)
|
||
SendImmediately=False;
|
||
CleanRealOutTOC();
|
||
CleanTempOutTOC();
|
||
SetSendQueue();
|
||
}
|
||
return nil;
|
||
}
|
||
|
||
/************************************************************************
|
||
* threadSwitchProcIn - switch intra-thread globals in
|
||
************************************************************************/
|
||
pascal void ThreadSwitchProcIn (ThreadID threadBeingSwitched, void *switchProcParam)
|
||
{
|
||
#pragma unused (threadBeingSwitched)
|
||
#if !TARGET_RT_MAC_CFM
|
||
long currentA5, myA5;
|
||
#endif
|
||
threadDataHandle threadData;
|
||
threadContextDataPtr threadContext;
|
||
#if __profile__
|
||
//short profilerWas = ProfilerGetStatus();
|
||
//ProfilerSetStatus(false);
|
||
#endif
|
||
|
||
ASSERT (switchProcParam);
|
||
|
||
threadData = (threadDataHandle) switchProcParam;
|
||
threadContext = &(*threadData)->threadContext;
|
||
|
||
#if !TARGET_RT_MAC_CFM
|
||
myA5 = threadContext->appsA5;
|
||
currentA5 = SetA5 (myA5);
|
||
#endif
|
||
|
||
// restore thread-globals
|
||
CurThreadGlobals = threadContext->newThreadGlobals;
|
||
#ifdef TASK_PROGRESS_ON
|
||
ProgWindow = TaskProgressWindow;
|
||
#endif
|
||
// make sure curresfile is thread's SettingsRefN
|
||
if (SettingsRefN!=-1) UseResFile(SettingsRefN);
|
||
|
||
#ifdef TASK_PROGRESS_ON
|
||
#ifdef NEVER
|
||
if (TaskProgressWindow)
|
||
{
|
||
ThreadID threadID, oldThreadID;
|
||
|
||
/* we're actually still in the main thread right now. so before we update the task progress beat,
|
||
set this thread's id to the main thread's id */
|
||
InvalTaskProgressBeat((*threadData)->prbl);
|
||
oldThreadID = (*threadData)->threadID;
|
||
GetCurrentThread (&threadID);
|
||
(*threadData)->threadID = threadID;
|
||
UpdateMyWindow(GetMyWindowWindowPtr(TaskProgressWindow));
|
||
(*threadData)->threadID = oldThreadID;
|
||
}
|
||
#endif
|
||
#endif
|
||
|
||
#if !TARGET_RT_MAC_CFM
|
||
myA5 = SetA5 (currentA5);
|
||
#endif
|
||
#if __profile__
|
||
//ProfilerSwitchToThread((*threadData)->threadRef);
|
||
//ProfilerSetStatus(profilerWas);
|
||
#endif
|
||
#ifdef DEBUG
|
||
(*threadData)->switchInTime = TickCount();
|
||
(*threadData)->switchCount++;
|
||
#endif
|
||
}
|
||
|
||
/************************************************************************
|
||
* threadSwitchProcOut - switch intra-thread globals out
|
||
* switch main-thread globals in
|
||
************************************************************************/
|
||
pascal void ThreadSwitchProcOut (ThreadID threadBeingSwitched, void *switchProcParam)
|
||
{
|
||
#pragma unused (threadBeingSwitched)
|
||
#if !TARGET_RT_MAC_CFM
|
||
long currentA5, myA5;
|
||
#endif
|
||
threadDataHandle threadData = nil;
|
||
threadContextDataPtr threadContext = nil;
|
||
#if __profile__
|
||
//short profilerWas = ProfilerGetStatus();
|
||
//ProfilerSetStatus(false);
|
||
#endif
|
||
|
||
ASSERT (switchProcParam);
|
||
threadData = (threadDataHandle) switchProcParam;
|
||
threadContext = &(*threadData)->threadContext;
|
||
|
||
#if !TARGET_RT_MAC_CFM
|
||
myA5 = threadContext->appsA5;
|
||
currentA5 = SetA5 (myA5);
|
||
#endif
|
||
|
||
// save globals from this thread
|
||
threadContext->newThreadGlobals = CurThreadGlobals;
|
||
CurThreadGlobals->tResRefN = CurResFile ();
|
||
|
||
// restore main thread-globals
|
||
CurThreadGlobals = &ThreadGlobals;
|
||
UseResFile (SettingsRefN);
|
||
|
||
|
||
#ifdef TASK_PROGRESS_ON
|
||
#ifdef NEVER
|
||
if (TaskProgressWindow)
|
||
{
|
||
InvalTaskProgressBeat((*threadData)->prbl);
|
||
UpdateMyWindow(GetMyWindowWindowPtr(TaskProgressWindow));
|
||
}
|
||
#endif
|
||
#endif
|
||
|
||
#if !TARGET_RT_MAC_CFM
|
||
myA5 = SetA5 (currentA5);
|
||
#endif
|
||
#if __profile__
|
||
//ProfilerSwitchToThread(ProfilerGetMainThreadRef());
|
||
//ProfilerSetStatus(profilerWas);
|
||
#endif
|
||
#ifdef DEBUG
|
||
(*threadData)->totalTimeThread += (TickCount() - (*threadData)->switchInTime);
|
||
#endif
|
||
}
|
||
|
||
|
||
/************************************************************************
|
||
* SaveSettingsToMainThread - copy changed settings back to main
|
||
************************************************************************/
|
||
// popd resource is saved directly to the original settings file in DisposePOPD
|
||
static OSErr SaveSettingsToMainThread (threadDataHandle threadData)
|
||
{
|
||
OSErr theError = noErr;
|
||
PersHandle pers,
|
||
mainPers,
|
||
oldCurPers;
|
||
StackHandle prefStack;
|
||
short pref = -1;
|
||
Str255 string; // prefs shouldn't exceed 255 chars!!!
|
||
prefChangeRec prefChange;
|
||
|
||
ASSERT (threadData);
|
||
|
||
// prefs that were changed by thread should be changed
|
||
prefStack = (*threadData)->threadContext.prefStack;
|
||
(*threadData)->threadContext.prefStack=nil;
|
||
while (prefStack && !StackPop(&prefChange,prefStack))
|
||
{
|
||
oldCurPers = CurPers;
|
||
if ( (prefChange.persId && (CurPers = FindPersById(prefChange.persId)))
|
||
|| (!prefChange.persId && !(CurPers = nil)))
|
||
{
|
||
GetPref(string,prefChange.pref);
|
||
CurPers = oldCurPers;
|
||
|
||
ThreadSwitchProcOut(nil,threadData);
|
||
oldCurPers = CurPers;
|
||
if (CurPers = FindPersById (prefChange.persId))
|
||
SetPref(prefChange.pref,string);
|
||
CurPers = oldCurPers;
|
||
ThreadSwitchProcIn(nil,threadData);
|
||
}
|
||
else
|
||
CurPers = oldCurPers;
|
||
}
|
||
DisposeHandle ((Handle)prefStack);
|
||
|
||
// go through all personalities in thread and update associated data in main thread
|
||
for (pers=PersList;pers;pers=(*pers)->next)
|
||
{
|
||
// change context to main thread
|
||
ThreadSwitchProcOut (nil, threadData);
|
||
if (mainPers = FindPersById((*pers)->persId))
|
||
{
|
||
// (*mainPers)->sendQueue = (*pers)->sendQueue;
|
||
#ifdef DEBUG
|
||
if (!BUG6)
|
||
#endif
|
||
(*mainPers)->checkTicks = MAX((*mainPers)->checkTicks,(*pers)->checkTicks);
|
||
(*mainPers)->popSecure = (*pers)->popSecure;
|
||
if ((*pers)->dirty) (*mainPers)->dirty = 1;
|
||
(*mainPers)->noUIDL = (*pers)->noUIDL;
|
||
|
||
#ifdef IMAP
|
||
/* only copy passwords back if we're a check thread or a send thread using xtnd xmit */
|
||
/* or if this was an IMAP thread, and the passwords were invalidated */
|
||
if (((*threadData)->xferMailParams.check ||
|
||
((*threadData)->xferMailParams.send && (PrefIsSet(PREF_POP_SEND) || ShouldSMTPAuth()&&!PrefIsSet(PREF_SMTP_AUTH_NOTOK))))
|
||
|| (((*threadData)->currentTask > SendingTask) && ((*pers)->password[0] == 0) && ((*pers)->secondPass[0] == 0)))
|
||
#else
|
||
/* only copy passwords back if we're a check thread or a send thread using xtnd xmit */
|
||
if ((*threadData)->xferMailParams.check || ((*threadData)->xferMailParams.send && PrefIsSet(PREF_POP_SEND)))
|
||
#endif
|
||
{
|
||
PSCopy ((*mainPers)->password, (*pers)->password);
|
||
PSCopy ((*mainPers)->secondPass, (*pers)->secondPass);
|
||
}
|
||
}
|
||
ThreadSwitchProcIn (nil, threadData);
|
||
}
|
||
|
||
// Fix Prr in the main thread, mostly for benefit of broken NotifyNewMail
|
||
{
|
||
OSErr myPrr = Prr;
|
||
|
||
ThreadSwitchProcOut(nil,threadData);
|
||
Prr = myPrr;
|
||
ThreadSwitchProcIn(nil,threadData);
|
||
}
|
||
|
||
// Fix FixServers in the main thread
|
||
{
|
||
Boolean myFixServers = FixServers;
|
||
|
||
ThreadSwitchProcOut(nil,threadData);
|
||
FixServers = FixServers || myFixServers;
|
||
ThreadSwitchProcIn(nil,threadData);
|
||
}
|
||
return theError;
|
||
}
|
||
|
||
|
||
/************************************************************************
|
||
* CopySettingsForThread - copy settings for thread
|
||
************************************************************************/
|
||
static OSErr CopySettingsForThread (short sourceRefN, PersHandle sourcePerslist, short *destRefN, PersHandle *destPersList, PersHandle *destCurPers)
|
||
{
|
||
FSSpec tempSpec,
|
||
settingsSpec;
|
||
OSErr theError = noErr;
|
||
short oldRefN = CurResFile();
|
||
|
||
Zero(tempSpec);
|
||
|
||
MyThreadBeginCritical ();
|
||
SetMyCursor(watchCursor);
|
||
UpdateResFile(sourceRefN);
|
||
theError = GetFileByRef (sourceRefN, &settingsSpec);
|
||
if (!theError)
|
||
{
|
||
theError = NewTempSpec (Root.vRef,Root.dirId, nil, &tempSpec);
|
||
if (!theError)
|
||
{
|
||
theError = FSpDupFile (&tempSpec, &settingsSpec, True, False);
|
||
if (!theError)
|
||
{
|
||
*destRefN = FSpOpenResFile(&tempSpec, fsRdWrPerm); // change to RdWr
|
||
if (*destRefN == -1)
|
||
theError = ResError ();
|
||
|
||
// What about the cache? for now. we'll just leave it initialized to nil instead of copying it.
|
||
|
||
if (!theError)
|
||
{
|
||
// copy personalities
|
||
PersHandle oldPers,
|
||
clone,
|
||
lastClone = nil;
|
||
|
||
for (oldPers=sourcePerslist;oldPers && !theError;oldPers=(*oldPers)->next)
|
||
{
|
||
clone = oldPers;
|
||
if (!(theError = MyHandToHand((Handle *)&clone)))
|
||
{
|
||
(*clone)->next = nil;
|
||
if (lastClone)
|
||
(*lastClone)->next = clone;
|
||
else
|
||
*destPersList = clone;
|
||
lastClone = clone;
|
||
}
|
||
else FileSystemError(READ_SETTINGS,tempSpec.name,theError);
|
||
*destCurPers = *destPersList;
|
||
}
|
||
}
|
||
else FileSystemError(READ_SETTINGS,tempSpec.name,theError);
|
||
}
|
||
else FileSystemError(READ_SETTINGS,tempSpec.name,theError);
|
||
}
|
||
else FileSystemError(READ_SETTINGS,tempSpec.name,theError);
|
||
}
|
||
else FileSystemError(READ_SETTINGS,tempSpec.name,theError);
|
||
|
||
MyThreadEndCritical ();
|
||
if (theError)
|
||
{
|
||
DeleteSettingsForThread (destRefN);
|
||
}
|
||
UseResFile (oldRefN);
|
||
return (CommandPeriod ? userCanceledErr : theError);
|
||
}
|
||
|
||
/************************************************************************
|
||
* DeleteSettingsForThread - do it
|
||
************************************************************************/
|
||
static OSErr DeleteSettingsForThread (short *settingsRefN)
|
||
{
|
||
FSSpec tempSpec;
|
||
OSErr theError = noErr;
|
||
|
||
if (*settingsRefN == -1)
|
||
return noErr;
|
||
|
||
// close and delete temp settings file
|
||
theError = GetFileByRef (*settingsRefN, &tempSpec);
|
||
if (!theError)
|
||
{
|
||
CloseResFile (*settingsRefN);
|
||
*settingsRefN = -1;
|
||
theError = ResError ();
|
||
}
|
||
if (!theError)
|
||
theError = FSpDelete (&tempSpec);
|
||
|
||
ASSERT (!theError); // temp file should get deleted!!!
|
||
return theError;
|
||
}
|
||
|
||
|
||
/************************************************************************
|
||
* getNumBackgroundThreads - return number of background threads
|
||
************************************************************************/
|
||
#pragma segment Main
|
||
short GetNumBackgroundThreads (void)
|
||
{
|
||
return (gNumBackgroundThreads);
|
||
}
|
||
#pragma segment Threads
|
||
|
||
/************************************************************************
|
||
* PushThreadPrefChange -
|
||
************************************************************************/
|
||
OSErr PushThreadPrefChange (short pref)
|
||
{
|
||
OSErr err = threadNotFoundErr;
|
||
threadDataHandle threadData;
|
||
|
||
GetCurrentThreadData(&threadData);
|
||
|
||
if (threadData)
|
||
{
|
||
char hState;
|
||
prefChangeRec prefChange;
|
||
StackHandle prefStack = (*threadData)->threadContext.prefStack;
|
||
|
||
if (!prefStack)
|
||
return noErr;
|
||
hState = HGetState((Handle)threadData);
|
||
HLock ((Handle)threadData);
|
||
prefChange.pref = pref;
|
||
|
||
prefChange.persId = (CurThreadGlobals && CurPers) ? (*CurPers)->persId : 0;
|
||
err = StackPush(&prefChange,prefStack);
|
||
HSetState((Handle)threadData, hState);
|
||
}
|
||
return err;
|
||
}
|
||
|
||
/************************************************************************
|
||
* incrementNumBackgroundThreads - increase number of background threads
|
||
************************************************************************/
|
||
void IncrementNumBackgroundThreads (void)
|
||
{
|
||
gNumBackgroundThreads++;
|
||
}
|
||
|
||
/************************************************************************
|
||
* decrementNumBackgroundThreads - decrease number of background threads
|
||
************************************************************************/
|
||
void DecrementNumBackgroundThreads (void)
|
||
{
|
||
gNumBackgroundThreads--;
|
||
}
|
||
|
||
/************************************************************************
|
||
* threadsAvailable - are threads supported?
|
||
************************************************************************/
|
||
Boolean ThreadsAvailable (void)
|
||
{
|
||
long response;
|
||
short lastBit = 0;
|
||
static Boolean firstCall = true,
|
||
avail = false;
|
||
|
||
if (!firstCall)
|
||
return avail;
|
||
|
||
firstCall = false;
|
||
avail = false;
|
||
lastBit = (sizeof (response) * 8) - 1;
|
||
|
||
if (Gestalt (gestaltThreadMgrAttr, &response) != noErr)
|
||
return false;
|
||
if (BitTst(&response, lastBit - gestaltThreadMgrPresent) == false) /* If Thread Mgr isn't loaded */
|
||
return false;
|
||
|
||
#if TARGET_RT_MAC_CFM
|
||
// only applies to ppc
|
||
// if (GetCurrentISA() == kPowerPCISA)
|
||
// {
|
||
// if (BitTst(&response, lastBit - gestaltThreadsLibraryPresent) == false) /* If Thread Mgr Library isn't loaded */
|
||
// return false;
|
||
// the threadslib is imported weak-- check if YieldToAnyThread() resolved
|
||
if (YieldToAnyThread == (void *)kUnresolvedCFragSymbolAddress)
|
||
return false;
|
||
// }
|
||
#endif
|
||
|
||
avail = true;
|
||
return true;
|
||
}
|
||
|
||
/* folowing three functions primarily used in pop.c cause we want to write to the settings
|
||
file belonging to the main thread, not the background thread */
|
||
|
||
/************************************************************************
|
||
* GetResourceMainThread -
|
||
************************************************************************/
|
||
pascal Handle GetResourceMainThread(ResType theType,short theID)
|
||
{
|
||
short refN = SettingsRefN,
|
||
curRefN;
|
||
Handle res = nil;
|
||
|
||
SettingsRefN = GetMainGlobalSettingsRefN ();
|
||
curRefN = CurResFile ();
|
||
UseResFile (SettingsRefN);
|
||
res = GetResource_(theType, theID);
|
||
SettingsRefN = refN;
|
||
UseResFile (curRefN);
|
||
return (res);
|
||
}
|
||
|
||
/************************************************************************
|
||
* ZapSettingsResourceMainThread -
|
||
************************************************************************/
|
||
OSErr ZapSettingsResourceMainThread(OSType type, short id)
|
||
{
|
||
OSErr theError = noErr;
|
||
short refN = SettingsRefN;
|
||
|
||
SettingsRefN = GetMainGlobalSettingsRefN ();
|
||
theError = ZapSettingsResource(type,id);
|
||
SettingsRefN = refN;
|
||
return (theError);
|
||
}
|
||
|
||
/************************************************************************
|
||
* AddMyResourceMainThread -
|
||
************************************************************************/
|
||
OSErr AddMyResourceMainThread(Handle h,OSType type,short id,ConstStr255Param name)
|
||
{
|
||
short refN = SettingsRefN,
|
||
curRefN;
|
||
OSErr err = noErr;
|
||
|
||
SettingsRefN = GetMainGlobalSettingsRefN ();
|
||
curRefN = CurResFile ();
|
||
AddMyResource(h,type,id,name);
|
||
err = ResError();
|
||
SettingsRefN = refN;
|
||
UseResFile (curRefN);
|
||
return err;
|
||
}
|
||
|
||
/************************************************************************
|
||
* SetThreadGlobalCommandPeriod -
|
||
************************************************************************/
|
||
void SetThreadGlobalCommandPeriod (ThreadID threadID, Boolean value)
|
||
{
|
||
threadGlobalsPtr newGlobals = nil;
|
||
threadDataHandle threadData = nil;
|
||
|
||
GetThreadData (threadID, &threadData);
|
||
|
||
if (threadData && (newGlobals = (*threadData)->threadContext.newThreadGlobals))
|
||
newGlobals->tCommandPeriod = value;
|
||
}
|
||
|
||
/************************************************************************
|
||
* GetMainGlobalSettingsRefN -
|
||
************************************************************************/
|
||
short GetMainGlobalSettingsRefN (void)
|
||
{
|
||
return (ThreadGlobals.tSettingsRefN);
|
||
}
|
||
|
||
/************************************************************************
|
||
* MyBeginCritical -
|
||
************************************************************************/
|
||
void MyThreadBeginCritical (void)
|
||
{
|
||
++gCriticalSection;
|
||
}
|
||
|
||
/************************************************************************
|
||
* MyEndCritical -
|
||
************************************************************************/
|
||
void MyThreadEndCritical (void)
|
||
{
|
||
if (--gCriticalSection < 0)
|
||
gCriticalSection = 0;
|
||
}
|
||
|
||
/************************************************************************
|
||
* MyYieldToAnyThread -
|
||
************************************************************************/
|
||
OSErr MyYieldToAnyThread (void)
|
||
{
|
||
OSErr theError = noErr;
|
||
|
||
#ifdef DEBUG
|
||
CheckSelectedGlobals ();
|
||
#endif
|
||
if (ThreadsAvailable())
|
||
{
|
||
if (!gCriticalSection)
|
||
{
|
||
short curRes = CurResFile(); // Thread might change res file
|
||
|
||
theError = YieldToAnyThread();
|
||
ThreadYieldTicks = TickCount();
|
||
UseResFile(curRes);
|
||
}
|
||
else if (InAThread() && NEED_YIELD)
|
||
WNELo(nil,nil,nil); // give minimal time to other apps
|
||
}
|
||
return theError;
|
||
}
|
||
|
||
/************************************************************************
|
||
* YieldCPUNow - give up the cpu, period
|
||
************************************************************************/
|
||
void YieldCPUNow(void)
|
||
{
|
||
ThreadYieldTicks = 0;
|
||
if (!InAThread()) CyclePendulum();
|
||
MyYieldToAnyThread();
|
||
}
|
||
|
||
/************************************************************************
|
||
* MyInitThreads -
|
||
* only call this from main thread during initialization
|
||
************************************************************************/
|
||
OSErr MyInitThreads (void)
|
||
{
|
||
#ifdef DEBUG_THREAD
|
||
SetDebuggerNotificationProcs(MyDebuggerNewThread, MyDebuggerDisposeThread, MyDebuggerThreadScheduler);
|
||
#endif
|
||
return (GetCurrentThread (&gMainThreadID));
|
||
}
|
||
|
||
/************************************************************************
|
||
* inAThread - am I running from a thread?
|
||
************************************************************************/
|
||
Boolean InAThread (void)
|
||
{
|
||
ThreadID threadID;
|
||
|
||
if (!ThreadsAvailable ())
|
||
return (false);
|
||
GetCurrentThread (&threadID);
|
||
return (threadID != gMainThreadID);
|
||
}
|
||
|
||
/************************************************************************
|
||
* threadTermination - dispose of memory when thread dies
|
||
************************************************************************/
|
||
pascal void ThreadTermination (ThreadID threadTerminated, void *terminationProcParam)
|
||
{
|
||
threadDataHandle threadData;
|
||
|
||
DecrementNumBackgroundThreads ();
|
||
if (threadData = (threadDataHandle) terminationProcParam)
|
||
{
|
||
WindowPtr TaskProgressWindowWP;
|
||
#ifdef DEBUG
|
||
long totalTicks = 0;
|
||
long perc = 0;
|
||
#endif
|
||
if ((*threadData)->xferMailParams.check)
|
||
CheckThreadRunning = false;
|
||
if ((*threadData)->xferMailParams.send)
|
||
SendThreadRunning = false;
|
||
#ifdef DEBUG_THREAD
|
||
MyDebuggerDisposeThread((*threadData)->threadContext.threadID);
|
||
#endif
|
||
#if __profile__
|
||
ProfilerDeleteThread ((*threadData)->threadRef);
|
||
#endif
|
||
RemoveProgressTask(threadData);
|
||
DisposeThreadGlobals ((*threadData)->threadContext.newThreadGlobals);
|
||
if ((*threadData)->threadContext.prefStack) // should be set to nil in SaveSettingsToMainThread
|
||
DisposeHandle ((Handle)(*threadData)->threadContext.prefStack);
|
||
ThreadSwitchProcOut (threadTerminated, terminationProcParam);
|
||
#ifdef DEBUG
|
||
// log totalTimeAll, totalTimeThread, switchCount
|
||
totalTicks = TickCount()-(*threadData)->startTime;
|
||
perc = FracMul(FracDiv((*threadData)->totalTimeThread, totalTicks), 100);
|
||
// perc = (long) (((float)(*threadData)->totalTimeThread/(float)totalTicks) * 100);
|
||
ComposeLogS(LOG_TPUT,nil,"\pTotal ticks %d; %p%p Thread ticks %d; Percent %d; Switch count: %d; Ticks/Switch: %d",totalTicks,(*threadData)->xferMailParams.check ? "\pCheck" : "\p",(*threadData)->xferMailParams.send ? "\p Send" : "\p", (*threadData)->totalTimeThread,perc,(*threadData)->switchCount, (*threadData)->totalTimeThread/(*threadData)->switchCount);
|
||
#endif
|
||
#ifdef TASK_PROGRESS_ON
|
||
if ((*threadData)->stopButton)
|
||
{
|
||
SetControlVisibility((*threadData)->stopButton,false,false);
|
||
DisposeControl((*threadData)->stopButton);
|
||
}
|
||
ASSERT((*threadData)->prbl);
|
||
DisposProgress((*threadData)->prbl);
|
||
#endif
|
||
LL_Remove(gThreadData,threadData,(threadDataHandle));
|
||
DisposeHandle ((Handle) threadData);
|
||
threadData = nil;
|
||
TaskProgressWindowWP = GetMyWindowWindowPtr(TaskProgressWindow);
|
||
#ifdef TASK_PROGRESS_ON
|
||
if (TaskProgressWindow && GetWindowKind(TaskProgressWindowWP)==TASKS_WIN)
|
||
{
|
||
#ifdef BATCH_DELIVERY_ON
|
||
if (!GetNumBackgroundThreads() && !TaskDontAutoClose && PrefIsSet(PREF_TASK_PROGRESS_AUTO) && !IsWazoo(TaskProgressWindowWP) && !NewError)
|
||
#else
|
||
if (!GetNumBackgroundThreads() && !TaskDontAutoClose && PrefIsSet(PREF_TASK_PROGRESS_AUTO) && !NeedToFilterIn && !IsWazoo(TaskProgressWindowWP) && !NewError)
|
||
#endif
|
||
CloseMyWindow(TaskProgressWindowWP);
|
||
else
|
||
InvalContent(TaskProgressWindow);
|
||
}
|
||
#endif
|
||
}
|
||
}
|
||
|
||
#endif
|
||
|
||
|
||
/* This is here because we are seeing some global handles get trashed on 10.3.7/8/9 and 10.4 */
|
||
/* They show up in crashes in FindWazoo, and other places */
|
||
|
||
static Boolean ValidPtr ( Ptr p ) { return ( 0 == (((unsigned long) p ) & 0x03 )); }
|
||
static Boolean ValidHandle ( Handle h ) { return ( 0 == (((unsigned long) h ) & 0x03 )) && ValidPtr ( *h ); }
|
||
|
||
/* Cheap knockoff of the data structures that are private to wazoo.c */
|
||
typedef struct privWazooDataStruct **privWazooDataHandle;
|
||
typedef struct privWazooDataStruct
|
||
{
|
||
short current; // Which one is currently active? (0 - N-1)
|
||
privWazooDataHandle next;
|
||
MyWindowPtr win;
|
||
Handle list; // Wazoo list resource
|
||
ControlHandle hTabCtrl;
|
||
ControlHandle hTabColorCtrl;
|
||
} privWazooData;
|
||
|
||
extern privWazooDataHandle gWazooListHead;
|
||
|
||
/* Another cheap knockoff - this one from linkmng.c */
|
||
typedef struct privHistoryDStruct
|
||
{
|
||
FSSpec spec; /* the history file */
|
||
Handle theData; /* the toc */
|
||
Boolean ro; /* read only */
|
||
Boolean dirty; /* is the history file dirty? */
|
||
} privHistoryDesc, *privHistoryDPtr, **privHistoryDHandle;
|
||
|
||
extern privHistoryDHandle gHistories;
|
||
|
||
|
||
void CheckSelectedGlobals () {
|
||
int i, count;
|
||
Handle h;
|
||
privWazooDataHandle wazoo;
|
||
|
||
// First, the nicknames
|
||
if ( NULL != Aliases )
|
||
{
|
||
ASSERT ( ValidHandle ((Handle) Aliases ));
|
||
count = GetHandleSize ((Handle) Aliases ) / sizeof ( AliasDesc );
|
||
for ( i = 0; i < count; i++ )
|
||
{
|
||
h = (Handle) (*Aliases) [ i ].theData;
|
||
if ( NULL != h )
|
||
ASSERT ( ValidHandle ( h ));
|
||
}
|
||
}
|
||
|
||
// Now, the Wazoo list
|
||
wazoo = gWazooListHead;
|
||
while ( NULL != wazoo )
|
||
{
|
||
ASSERT ( ValidHandle ((Handle) wazoo ));
|
||
ASSERT ( ValidHandle ( (*wazoo)->list ));
|
||
if ( NULL != (*wazoo)->next )
|
||
ASSERT ( ValidHandle ((Handle) (*wazoo)->next ));
|
||
wazoo = (*wazoo)->next;
|
||
}
|
||
|
||
// Finally, the Link History
|
||
if ( NULL != gHistories )
|
||
{
|
||
ASSERT ( ValidHandle ((Handle) gHistories ));
|
||
count = GetHandleSize ((Handle) gHistories ) / sizeof ( privHistoryDesc );
|
||
for ( i = 0; i < count; i++ )
|
||
{
|
||
h = (Handle) (*gHistories) [ i ].theData;
|
||
if ( NULL != h )
|
||
ASSERT ( ValidHandle ( h ));
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
/*
|
||
-----------------------------------------------------------------------------------------------------------------------
|
||
DESIGN
|
||
-----------------------------------------------------------------------------------------------------------------------
|
||
|
||
Here's my plan for implementing phase 1 of threads. Comments are welcome.
|
||
|
||
I am using the Thread Manager to implement this stuff. All of the thread changes are #ifdefed so we can switch off threading for debugging. The Checkmail thread is mostly written.
|
||
|
||
Here's a breakdown of the changes:
|
||
|
||
General Threading
|
||
|
||
Can we thread?
|
||
- during initialization, see if this OS supports threads. Warn and run single-threaded if we can't.
|
||
|
||
Make Progress Dialog thread-safe and modeless
|
||
- don't disable menus anymore (but do disable checkmail and sendmail)
|
||
- attach thread context data structure to the myWindowPtr structure. The thread context data structure contains two copies of certain global variables. One copy is global to the main thread, and the other is global to the background thread. Examples of some of these thread-sensitive variables are: ProgWindow, CommandPeriod, and StringCache. These globals are switched in and out by the thread context switch procs, which are automatically called by the Thread Manager.
|
||
- Replace Swinging Pendulum and Spinning Beach Ball with Arrow cursor
|
||
- Yield to other threads from Progress() function
|
||
- replace progreessButton () and progressKey () callbacks with thread-aware versions
|
||
|
||
Make network code thread-safe
|
||
I'm not sure how much work is involved here or if it's even necessary for phase 1. For now I've just disabled the Ph and Finger buttons when a checkmail or sendmail thread is in progress.
|
||
|
||
Cooperation
|
||
CHANGED -- Yield once from main event loop, which is in the main thread. Background threads will also yield from the Progress() function. We need to be extra cautious about "locking up" the main thread by not yielding enough from background threads.
|
||
We're now yielding from WNE. The tcp code calls this when it's waiting to connect. Previously, not yielding from this code locked the UI.
|
||
Another big change is, we're not sleeping when a background thread is running. We were giving up too much time to other apps when the thread was running.
|
||
|
||
Segmentation
|
||
For now, I've disabled unloadSegs () and unloadUneeded () while a thread is running. Unloading segments that are in use by another thread is not a healthy thing to do! It sounds like we will be doing away with segmentation so these functions will not need to be made thread-safe?
|
||
|
||
|
||
Check Mail Thread
|
||
-----------------
|
||
from main thread...
|
||
- create thread (allocate and initialize data and install procptrs: thread entry point, context switch functions, thread termination function)
|
||
- continue cycling through event loop (and call thread-aware progress callbacks when cancel button hit or command-. hit)
|
||
|
||
from check mail thread...
|
||
- copy settings, stringcache, and personality data (since user could change these while the thread is running)
|
||
- open thread-safe, modeless progress dialog
|
||
- run modified xfermail()
|
||
download messages to temporary In mailbox
|
||
make progress modal
|
||
run filters on temp mailbox
|
||
transfer unfiltered messages to In mailbox
|
||
- close progress dialog
|
||
- clean up (dispose of memory)
|
||
|
||
Send Mail Thread 1 (implemented)
|
||
------------------
|
||
from main thread...
|
||
- create thread (allocate and initialize data and install procptrs: thread entry point, context switch functions, thread termination function)
|
||
- copy queued messages in Out mailbox to temporary Out mailbox
|
||
- set state of messages in out box to BUSY_SENDING (they're locked and unmodifiable)
|
||
- continue cycling through event loop (and call thread-aware progress callbacks when cancel button hit or command-. hit)
|
||
|
||
from send mail thread...
|
||
- copy settings, stringcache, and personality data (since user could change these while the thread is running)
|
||
- open thread-safe, modeless progress dialog
|
||
- run modified xfermail()
|
||
run emsapi plug-ins (shouldn't be a problem unless plug-in calls YieldToAnyThread ())
|
||
expand nicknames
|
||
parse headers (to, from, fcc...)
|
||
upload messages from the temporary Out mailbox
|
||
mark state of summary (i.e. SENT)
|
||
|
||
make progress modal
|
||
- for each message in out box marked as BUSY_SENDING
|
||
set state of summary (i.e. SENT or QUEUED)
|
||
expand nicknames
|
||
fcc
|
||
filter
|
||
delete summary if pref set
|
||
delete summary in temp out box
|
||
- close progress dialog
|
||
- clean up (dispose of memory)
|
||
|
||
|
||
Send Mail Thread 2 (future implementation)
|
||
------------------
|
||
from main thread...
|
||
- create thread (allocate and initialize data and install procptrs: thread entry point, context switch functions, thread termination function)
|
||
+ spool queued messages in out box (expand nicknames, encode attachments, run EMSAPI q4transmission plug-ins) with name = uidHash
|
||
- set state of messages in out box to BUSY_SENDING (they're locked and unmodifiable)
|
||
- continue cycling through event loop (and call thread-aware progress callbacks when cancel button hit or command-. hit)
|
||
|
||
from send mail thread...
|
||
- copy settings, stringcache, and personality data (since user could change these while the thread is running)
|
||
- open thread-safe, modeless progress dialog
|
||
- run modified xfermail()
|
||
+ upload messages from spool directory
|
||
|
||
make progress modal
|
||
- for each locked summary entry
|
||
set state of summary (i.e. SENT or QUEUED)
|
||
fcc
|
||
filter
|
||
delete summary if pref set
|
||
delete spool file
|
||
- close progress dialog
|
||
- clean up (dispose of memory)
|
||
|
||
-----------------------------------------------------------------------------------------------------------------------
|
||
BUGS
|
||
-----------------------------------------------------------------------------------------------------------------------
|
||
|
||
To do:
|
||
|
||
- don't bring up filter progress window unless process takes more than 3 seconds
|
||
- allow filtering during thread
|
||
- test for weak imports in threads available
|
||
- send queued messages after send thread finishes (watch for ppp hanging up between xfers)
|
||
- thread should have own toclist and messlist
|
||
|
||
Known bugs:
|
||
|
||
- unloadUneeded () and unloadSegs() disabled when thread started
|
||
- changing pop accounts while checking mail - pw should become invalid
|
||
- some sent messages are still editable
|
||
|
||
Non-reproducible bugs:
|
||
- editing <20> (busy sending) messages (chris pepper)
|
||
- can't edit contents of mess from aborted send
|
||
- possible race condition when sending
|
||
|
||
Fixed bugs:
|
||
|
||
- background check mail reporting error -38 when downloading mail 3/19/97
|
||
- messages aren't written to temp toc 3/20/97
|
||
- check mail is checking all personalities 3/20/97
|
||
- quitting while check mail thread running causes crash 4/97
|
||
- not all messages transfered from temp.in to in mailbox 4/11/97
|
||
- send mail unsupported -- started support 4/15/97
|
||
- auto-check needs to be threaded. it's interfering with threaded check. 4/15/97
|
||
- repeating check mail when auto-checking 4/18/97
|
||
- fix warning verbiage when TM not supported and run single-threaded. 4/29/97
|
||
- out.temp mailbox can't be rebuilt on startup/NickMatchFound (steve) 4/30/97
|
||
- temp toc is grafted in-- should be hidden 5/1/97
|
||
- messages sent multiple times when left in out temp 5/2/97
|
||
- location of progress window not saved 5/2/97
|
||
- FCC and filter not working yet for outgoing messages 5/2/97
|
||
- not sending queued messages when quitting/ trash "out of date" warning sometimes causes crash 5/5/97
|
||
- modal dialogs crashing 5/6/97
|
||
- font changing/port problem/ PopGWorld assertion failing (steve) 5/6/97
|
||
- "You have new mail" dialog box crash (john) 5/6/97
|
||
- get password not hiding text 5/6/97
|
||
- popd lmos data not copied to original settings fork 5/6/97
|
||
- when progress window becomes modal, it should change appearance. 5/6/97
|
||
- option-cmd-W cmd-M cmd-1 (not processing keyboard commands besides cancel) 5/9/97
|
||
- gworld stack - thread now maintains it's own 5/9/97
|
||
- filtering mail while check mail running 5/13/97
|
||
- closing progress window crash 5/13/97
|
||
- should wait for idle time before modeless dlog turns modal 5/13/97
|
||
- settings dialog turns modeless when check mail brings in box to front 5/13/97
|
||
- personality fields (for the main thread) (e.g. passwords) aren't updated 5/14/97
|
||
- logging 5/14/97
|
||
- timed queued messages not being sent 5/15/97
|
||
- "Send Queued Messages" deactive when check mail without sending and there's a queued mesg 5/15/97
|
||
- 68k version crashes while in threads (but not when program locked-- suspect it's segmentation fault) 5/16/97
|
||
- open in.temp instead of in for incoming filter with any header (pete) 5/21/97
|
||
- open message filter for incoming opens and closes mesg 5/21/97
|
||
- filter reply with on incoming messages creates mesg but doesn't send (steve) 5/22/97
|
||
- do something so steve doesn't get scared of "waiting for idle" progress dlog 5/22/97
|
||
(remove progress bar, resource for idle time, change stop to go)
|
||
- deleting message from toc by hitting delete causes slow update when waiting for idle time 5/22/97
|
||
- deleting message from toc by hitting delete changes cursor to beach ball 5/22/97
|
||
- hang when progress dialogs disabled (andrew starr) 5/22/97
|
||
- SetPref needs to be thread-aware (steve) 5/23/97
|
||
- mesgs with bad addresses not editable when brought up, then crashing 5/23/97
|
||
- should automatically rebuild temp in/out mailboxes instead of asking user 5/23/97
|
||
- SetupXferMail () needs to handle errors better 5/27/97
|
||
- don't need to wait for idle time when progress frontmost 5/27/97
|
||
- keeps downloading message that was partially downloaded then fetched (josh) 5/28/97
|
||
- cleaning up after checking mail too long (pete) 5/28/97
|
||
- filter to set server options to delete- doesn't work (pete) 5/29/97
|
||
- need to fix out.temp automatically when corrupt 5/30/97
|
||
- progress dialog flickers on and off during checkmail with send 5/30/97
|
||
- progress dialog waits twice 5/30/97
|
||
- buildtoc.c line 27 (not checking for nil toc) 6/10/97
|
||
- after progress window sleeps, sometimes outgoing filters don't work 6/11/97
|
||
- passwords not preserved for session 6/12/97
|
||
- repeatedly checking mail 6/12/97
|
||
- typing is slower when waiting for idle time 6/16/97
|
||
- use global structs in globals.c 6/16/97
|
||
- unsent messages are filtered anyway 6/19/97
|
||
- don't need to wait for idle time when starting background check mail 6/19/97
|
||
- clicking stop button sometimes doesn't cancel thread 6/20/97 by John B
|
||
- hitting "allow all connections" and "work offline" not working 6/24/97
|
||
- closing all windows causes crash (was closing progwindow and message 6/24/97
|
||
and toc which were being used by thread)
|
||
- memory leak size = 26600 6/26/97
|
||
- globals causing heap corruption/crash 6/26/97
|
||
- ThreadsAvailable failing for 68k 6/26/97
|
||
- ASSERT(CurResFile()==SettingsRefN) failing (usually when app is in background and check mail starts) 6/27/97
|
||
Always happens when check mail, and bring up In mailbox from menu -- flushtocs (), mightswitch ()?
|
||
- close all messages causes crash -- in.temp getting closed
|
||
- not filtering "old" messages in temp boxes
|
||
- increase stack size for thread when too small
|
||
- crash recovery - need to mark messages as sent?
|
||
- slow typing
|
||
- downloading messages still really slow-- don't yield as much when !active, look into NEEDYIELD, profiler
|
||
- don't use reserve memory for thread creation
|
||
- move filtering to main thread
|
||
- don't download duplicate messages in in.temp
|
||
- SMTP error messages open in front of Filtering dialog
|
||
- update status of outgoing immediately 9/4/97
|
||
- redo filter temp out toc 9/4/97
|
||
- don't allow user to change status
|
||
- don't read filters when sending messages
|
||
- improve error handling for incoming/outgoing messages, MDN header, toc flags
|
||
- implement transport status window
|
||
- send immediately doesn't work
|
||
- network code isn't multi-threaded; only one connection at a time
|
||
- about box, settings shouldn't stall background thread
|
||
- link error in 68k version
|
||
- set skipped flag for encoding errors
|
||
- unqueue edited messages
|
||
- uucp unsupported
|
||
- hitting cancel when copying settings file crashes?
|
||
|
||
Phase 2:
|
||
|
||
- need to spool outgoing files instead of xfering to temp out mbox
|
||
|
||
*/
|