STDMETHODIMP CPigMissionParams::get_Experimental(VARIANT_BOOL* Experimental)
{
XLock lock(this);
USES_CONVERSION;
CLEAROUT(Experimental, VARBOOL(m_mp.bExperimental));
return S_OK;
}
HRESULT CPigShip::CreateCommandWrapper(Command cmd, IAGCCommand** ppCommand)
{
// Initialize the [out] parameter
CLEAROUT(ppCommand, (IAGCCommand*)NULL);
// Create a new AGC.Command object
IAGCCommandPrivatePtr spCmd;
RETURN_FAILED(spCmd.CreateInstance(CLSID_AGCCommand));
// Get the command target and id
ImodelIGC* pModel = GetIGC()->GetCommandTarget(cmd);
const CommandID idCmd = GetIGC()->GetCommandID(cmd);
// Get the strings for the command target and id
const char* pszTarget = pModel ? GetModelName(pModel) : NULL;
const char* pszVerb = (0 <= idCmd && idCmd < c_cidMax) ?
c_cdAllCommands[idCmd].szVerb : "";
// Initialize the new object
spCmd->Init(pszTarget, pszVerb);
// Query for the IAGCCommand interface
_SVERIFYE(spCmd->QueryInterface(IID_IAGCCommand, (void**)ppCommand));
// Indicate success
return S_OK;
}
STDMETHODIMP CPigMissionParams::get_CoreName(BSTR* bstrCoreName)
{
XLock lock(this);
USES_CONVERSION;
CLEAROUT(bstrCoreName, A2OLE(m_mp.szIGCStaticFile));
return S_OK;
}
STDMETHODIMP TCUtilImpl::CreateObject(BSTR bstrProgID, BSTR bstrComputer,
IUnknown** ppUnk)
{
// Initialize the [out] parameter
CLEAROUT(ppUnk, (IUnknown*)NULL);
// Convert the specified ProgID to a CLSID
CLSID clsid;
if (!BSTRLen(bstrProgID))
return E_INVALIDARG;
RETURN_FAILED(CLSIDFromProgID(bstrProgID, &clsid));
// Initialize the COSERVERINFO and MULTI_QI structures
COSERVERINFO csi = {0, bstrComputer, NULL, 0};
MULTI_QI mqi[] =
{
{&IID_IUnknown , NULL, S_OK},
{&IID_IDispatch , NULL, S_OK},
{&IID_IConnectionPointContainer, NULL, S_OK},
};
const static ULONG cMQI = sizeofArray(mqi);
// Determine if the specified computer name is definitely local
bool bLocalForSure = true;
if (BSTRLen(bstrComputer))
{
TCHAR szLocal[MAX_COMPUTERNAME_LENGTH + 1];
DWORD cchLocal = sizeofArray(szLocal);
GetComputerName(szLocal, &cchLocal);
USES_CONVERSION;
bLocalForSure = !_tcsicmp(szLocal, OLE2CT(bstrComputer));
}
DWORD dwClsCtx = bLocalForSure ? CLSCTX_SERVER : CLSCTX_REMOTE_SERVER;
// Attempt to create the instance
HRESULT hr = CoCreateInstanceEx(clsid, NULL, dwClsCtx, &csi, cMQI, mqi);
if (FAILED(hr))
{
_TRACE_BEGIN
_TRACE_PART1("TCCreateObject failed: hr=0x%08X", hr);
_TRACE_PART1(", dwClsCtx=%hs", (CLSCTX_SERVER == dwClsCtx) ?
"CLSCTX_SERVER" : "CLSCTX_REMOTE_SERVER");
_TRACE_PART1(", ProgID=\"%ls\"", bstrProgID);
_TRACE_PART1(", Computer= \"%ls\"\n", bstrComputer ?
bstrComputer : L"");
_TRACE_END
return hr;
}
// Copy the IUnknown interface pointer to the [out] parameter
*ppUnk = mqi[0].pItf;
// Release each interface not being returned
for (ULONG i = 1; i < cMQI; ++i)
if (mqi[i].pItf)
mqi[i].pItf->Release();
// Return the result of the QI for IUnknown
return mqi[0].hr;
}
STDMETHODIMP CPigMissionParams::get_Pods(VARIANT_BOOL* Pods)
{
XLock lock(this);
USES_CONVERSION;
CLEAROUT(Pods, (VARIANT_BOOL)m_mp.bEjectPods);
return S_OK;
}
STDMETHODIMP CPigMissionParams::get_Developments(VARIANT_BOOL* Developments)
{
XLock lock(this);
USES_CONVERSION;
CLEAROUT(Developments, VARBOOL(m_mp.bAllowDevelopments));
return S_OK;
}
HRESULT CPigEngine::get_LobbyMode(PigLobbyMode* peMode)
{
// Initialize the [out] parameter
XLock lock(this);
CLEAROUT(peMode, m_eLobbyMode);
return S_OK;
}
HRESULT CPigEngine::get_ZoneAuthTimeout(long* pnMilliseconds)
{
// Initialize the [out] parameter
XLock lock(this);
CLEAROUT(pnMilliseconds, m_nZoneAuthTimeout);
return S_OK;
}
STDMETHODIMP CTCPropBagOnRegKey::get_ObjectCLSID(BSTR* pbstrCLSID)
{
try
{
// Initialize the [out] parameter
CLEAROUT(pbstrCLSID, (BSTR)NULL);
// Lock the object
XLock lock(this);
// Ensure that an internal property bag object has been created
if (!m_pBag)
return E_UNEXPECTED;
// Forward the call to the internal property bag object
CLSID clsid;
RETURN_FAILED(m_pBag->GetObjectCLSID(_bstr_t(), clsid));
// Convert the CLSID to a string
*pbstrCLSID = BSTRFromGUID(clsid).copy();
// Indicate success
return S_OK;
}
TC_CATCH_ALL("CTCPropBagOnRegKey::get_ObjectCLSID()",
RPC_E_SERVERFAULT)
}
STDMETHODIMP CPigBehaviorStack::get_Pig(IPig** ppPig)
{
CLEAROUT(ppPig, (IPig*)NULL);
assert(m_pPig);
IPigPtr spPig(m_pPig);
*ppPig = spPig.Detach();
return S_OK;
}
HRESULT CPigEngine::get_StateName(PigState ePigState, BSTR* pbstrPigState)
{
CLEAROUT(pbstrPigState, (BSTR)NULL);
LPCOLESTR pszPigState = NULL;
if (!TCLookupTable_FIND(StateNames, ePigState, pszPigState))
return E_INVALIDARG;
*pbstrPigState = SysAllocString(pszPigState);
return S_OK;
}
HRESULT CPigEngine::get_Pigs(IPigs** ppPigs)
{
assert(m_pPigs);
// Initialize the [out] parameter
CLEAROUT(ppPigs, (IPigs*)NULL);
// Query the pigs collection object for the IPigs interface
return m_pPigs->QueryInterface(IID_IPigs, (void**)ppPigs);
}
HRESULT CPigEngine::CreatePig(BSTR bstrType, BSTR bstrCommandLine, IPig** ppPig)
{
// Initialize the [out] parameter
CLEAROUT(ppPig, (IPig*)NULL);
// Lock the object for the following validation checks
{
XLock lock(this);
// Ensure that the scripts have been loaded
RETURN_FAILED(EnsureScriptsAreLoaded());
// Ensure that the MissionServer property is not empty
if (!m_bstrMissionServer.Length())
return AtlReportError(CLSID_PigSession, IDS_E_NO_MISSIONSRV,
IID_IPigSession, 0, _Module.GetResourceInstance());
// Get the number of pigs that exist
long cPigs = 0;
if (m_pPigs)
_SVERIFYE(m_pPigs->get_Count(&cPigs));
// Get the maximum number of pigs allowed
long nMaxPigs = 0;
_SVERIFYE(get_MaxPigs(&nMaxPigs));
// Check for maximum pigs
if (nMaxPigs >= 0 && cPigs >= nMaxPigs)
return AtlReportError(CLSID_PigSession, IDS_E_TOOMANYPIGS,
IID_IPigSession, 0, _Module.GetResourceInstance());
}
// bstrType is optional, so assign a default value if not specified
CComBSTR bstrTheType(bstrType);
if (!bstrTheType.Length())
bstrTheType = L"Default";
// Find the specified behavior type
CPigBehaviorScriptType* pBehaviorType = GetBehaviorType(bstrTheType);
if (!pBehaviorType)
return AtlReportError(CLSID_PigSession, IDS_E_CREATE_BEHAVIOR_TYPE,
IID_IPigSession, 0, _Module.GetResourceInstance());
// Create a new pig thread object and it's associated pig player object
DWORD dwGITCookie;
RETURN_FAILED(CPig::Create(pBehaviorType, bstrCommandLine, &dwGITCookie));
// Get an apartment-safe pointer to the pig object
RETURN_FAILED(GetInterfaceFromGlobal(dwGITCookie, IID_IPig, (void**)ppPig));
assert(*ppPig);
// Indicate success
return S_OK;
}
HRESULT CPigEngine::get_AccountServer(BSTR* pbstrServer)
{
// Initialize the [out] parameter
CLEAROUT(pbstrServer, (BSTR)NULL);
// Copy the requested value to the [out] parameters
XLock lock(this);
*pbstrServer = m_bstrAccountServer.Copy();
// Indicate success
return S_OK;
}
STDMETHODIMP CAdminSessionHelper::get_IsAllSrvRunning(VARIANT_BOOL* pbIsRunning)
{
// Open the mutex using the global name first
HANDLE hMutex = ::OpenMutex(SYNCHRONIZE, false, szAllSrvRunningGlobal);
if (!hMutex)
hMutex = ::OpenMutex(SYNCHRONIZE, false, szAllSrvRunning);
bool bRunning = NULL != hMutex;
if (bRunning)
::CloseHandle(hMutex);
CLEAROUT(pbIsRunning, VARBOOL(bRunning));
return S_OK;
}
HRESULT CPigEngine::get_MaxPigs(long* pnMaxPigs)
{
// Open the registry key of the AppID
CRegKey key;
RETURN_FAILED(_Module.OpenAppIDRegKey(key, KEY_READ));
// Get the requested value
DWORD nMaxPigs = DWORD(-1);
key.QueryValue((DWORD&)nMaxPigs, TEXT("MaxPigs"));
// Copy the requested value to the [out] parameter
CLEAROUT(pnMaxPigs, (long)nMaxPigs);
// Indicate success
return S_OK;
}
/*-------------------------------------------------------------------------
* get_ProductVersion()
*-------------------------------------------------------------------------
* Purpose:
* Determine the version number of AllSrv
*
*/
STDMETHODIMP CAdminSession::get_Version(IAGCVersionInfo** ppVersion)
{
// Initialize the [out] parameter
CLEAROUT(ppVersion, (IAGCVersionInfo*)NULL);
// Create an instance of the version object
IAGCVersionInfoPtr spVersion;
RETURN_FAILED(spVersion.CreateInstance(CLSID_AGCVersionInfo));
// Initialize the version object
TCHAR szModule[_MAX_PATH];
GetModuleFileName(_Module.GetModuleInstance(), szModule, sizeofArray(szModule));
RETURN_FAILED(spVersion->put_FileName(CComBSTR(szModule)));
// Detach the object to the [out] parameter
*ppVersion = spVersion.Detach();
// Indicate success
return S_OK;
}
/*-------------------------------------------------------------------------
* GetDescription()
*-------------------------------------------------------------------------
*
* Sample format:
*
* a-markcu1\2\ADMIN\991008\15:30:22
* curtc2\0\USER\990908\01:00:59
*
*/
STDMETHODIMP CAdminGame::get_Description(BSTR * pbstrDescription)
{
assert(GetIGC());
assert(GetHostIGC());
char szDescrip[128];
// cache machine name because this never changes
static char szMachine[32] = { 0 };
if (szMachine[0] == 0)
{
if (gethostname(szMachine, 32) != 0)
{
return Error("Cannont determine machine name.");
}
}
SYSTEMTIME * st = GetHostIGC()->GetStartTime();
// seperator is '\\' because it should be a character not allowed in a machine name
sprintf(szDescrip, "%s\\%d\\%s\\%02d%02d%02d\\%02d:%02d:%02d\\%0.64s",
szMachine,
GetIGC()->GetMissionID(),
GetIGC()->GetMissionParams()->bObjectModelCreated ? "ADMIN" : "USER",
st->wYear % 100,
st->wMonth,
st->wDay,
st->wHour,
st->wMinute,
st->wSecond,
GetIGC()->GetMissionParams()->strGameName);
CComBSTR bstr(szDescrip);
// Detach the string to the [out] parameter
CLEAROUT(pbstrDescription, (BSTR)bstr);
bstr.Detach();
return S_OK;
}
STDMETHODIMP CPigMissionParams::GetData(IStream** ppstm)
{
// Initialize the [out] parameter
CLEAROUT(ppstm, (IStream*)NULL);
// Create a stream on global
IStreamPtr spstm;
RETURN_FAILED(CreateStreamOnHGlobal(NULL, true, &spstm));
// Write the size of the data structure to the stream
UINT cb = sizeof(m_mp);
RETURN_FAILED(spstm->Write(&cb, sizeof(cb), NULL));
// Write the data structure to the stream
RETURN_FAILED(spstm->Write(&m_mp, cb, NULL));
// Detach the interface to the [out] parameter
*ppstm = spstm.Detach();
// Indicate success
return S_OK;
}
STDMETHODIMP CTCPropBagOnRegKey::get_Server(BSTR* pbstrServer)
{
try
{
// Initialize the [out] parameter
CLEAROUT(pbstrServer, (BSTR)NULL);
// Lock the object
XLock lock(this);
// Ensure that an internal property bag object has been created
if (!m_pBag)
return E_UNEXPECTED;
// Forward the call to the internal property bag object
*pbstrServer = m_pBag->GetServer(_bstr_t()).AllocSysString();
// Indicate success
return S_OK;
}
TC_CATCH_ALL("CTCPropBagOnRegKey::get_Server()", RPC_E_SERVERFAULT)
}
HRESULT CPigEngine::get_ArtPath(BSTR* pbstrArtPath)
{
// Initialize the [out] parameter
CLEAROUT(pbstrArtPath, (BSTR)NULL);
// Open the registry key of the AppID
CRegKey key;
RETURN_FAILED(_Module.OpenAppIDRegKey(key, KEY_READ));
// Read the value
TCHAR szArtPath[_MAX_PATH];
DWORD cch = sizeofArray(szArtPath);
long lr = key.QueryValue(szArtPath, TEXT("ArtPath"), &cch);
if (ERROR_SUCCESS != lr)
szArtPath[0] = TEXT('\0');
// Create a BSTR
USES_CONVERSION;
*pbstrArtPath = SysAllocString(T2COLE(szArtPath));
// Indicate success
return S_OK;
}
STDMETHODIMP TCUtilImpl::ObjectReference(IUnknown* pUnk,
BSTR* pbstrObjectReference)
{
// Initialize the [out] parameter
CLEAROUT(pbstrObjectReference, (BSTR)NULL);
// Create the object reference moniker
IMonikerPtr spMoniker;
RETURN_FAILED(CreateObjrefMoniker(pUnk, &spMoniker));
// Create a binding context
IBindCtxPtr spbc;
RETURN_FAILED(CreateBindCtx(0, &spbc));
// Get the displayable name of the moniker
TCCoTaskPtr<LPOLESTR> spszDisplayName;
RETURN_FAILED(spMoniker->GetDisplayName(spbc, NULL, &spszDisplayName));
// Create a BSTR from the display name
*pbstrObjectReference = SysAllocString(spszDisplayName);
// Indicate success or failure
return *pbstrObjectReference ? S_OK : E_OUTOFMEMORY;
}
/*-------------------------------------------------------------------------
* get_ProcessID()
*-------------------------------------------------------------------------
* Purpose:
* Determine the process identifier of this AllSrv process.
*
*/
STDMETHODIMP CAdminSession::get_ProcessID(long* pdwProcessID)
{
CLEAROUT(pdwProcessID, long(GetCurrentProcessId()));
return S_OK;
}
HRESULT CPigEngine::get_ScriptDir(BSTR* pbstrScriptDir)
{
CLEAROUT(pbstrScriptDir, (BSTR)NULL);
*pbstrScriptDir = m_bstrScriptDir.copy();
return S_OK;
}
/*-------------------------------------------------------------------------
* get__NewEnum()
*-------------------------------------------------------------------------
* Purpose:
* Provide iteration support for things (like VB/Javascript languages)
* that use this COM object.
*/
STDMETHODIMP CAdminUsers :: get__NewEnum(IUnknown** ppunkEnum)
{
// Clear the [out] parameter
CLEAROUT(ppunkEnum, (IUnknown*)NULL);
// Create a new CComEnum enumerator object
typedef CComObject<CComEnum<IEnumVARIANT, &IID_IEnumVARIANT, VARIANT,
_Copy<VARIANT> > > CEnum;
CEnum* pEnum = new CEnum;
assert(NULL != pEnum);
//
// Copy the pCAdminGame elements into to a temporary CComVariant vector
//
long cTotal;
get_Count(&cTotal);
CComVariant* pargTemp = new CComVariant[cTotal];
long i = 0;
if (m_pIGCmission)
{
//
// Iterate thru all ships in mission
//
for(ShipLinkIGC * plinkShip = m_pIGCmission->GetShips()->first(); plinkShip; plinkShip = plinkShip->next())
{
CFSShip * pfsShip = (CFSShip *) plinkShip->data()->GetPrivateData();
if (pfsShip->IsPlayer())
{
CFSPlayer * pfsPlayer = pfsShip->GetPlayer();
IAdminUser *pIAdminUser;
RETURN_FAILED (pfsPlayer->CAdminSponsor<CAdminUser>::Make(IID_IAdminUser, (void**)&pIAdminUser));
pfsPlayer->CAdminSponsor<CAdminUser>::GetLimb()->Init(pfsPlayer);
pargTemp[i] = pIAdminUser;
++i;
// at this point we now we are done. This is not only an optimization but
// a safeguard incase IGC is flawed.
if (i >= cTotal)
break;
}
}
}
else
{
//
// Iterate thru all missions
//
const ListFSMission * plistMission = CFSMission::GetMissions();
for (LinkFSMission * plinkMission = plistMission->first(); plinkMission; plinkMission = plinkMission->next())
{
CFSMission * pfsMission = plinkMission->data();
ImissionIGC * pIGCmission = pfsMission->GetIGCMission();
const ShipListIGC * plistShip = pIGCmission->GetShips();
//
// Iterate thru all ships in mission
//
for(ShipLinkIGC * plinkShip = plistShip->first(); plinkShip; plinkShip = plinkShip->next())
{
CFSShip * pfsShip = (CFSShip *) plinkShip->data()->GetPrivateData();
if (pfsShip->IsPlayer())
{
CFSPlayer * pfsPlayer = pfsShip->GetPlayer();
IAdminUser *pIAdminUser;
RETURN_FAILED (pfsPlayer->CAdminSponsor<CAdminUser>::Make(IID_IAdminUser, (void**)&pIAdminUser));
pfsPlayer->CAdminSponsor<CAdminUser>::GetLimb()->Init(pfsPlayer);
pargTemp[i] = pIAdminUser;
++i;
// at this point we now we are done. This is not only an optimization but
// a safeguard incase IGC is flawed.
if (i >= cTotal) goto exit_loops;
}
}
}
}
exit_loops:
// Initialize enumerator object with the temporary CComVariant vector
HRESULT hr = pEnum->Init(&pargTemp[0], &pargTemp[cTotal], NULL, AtlFlagCopy);
delete [] pargTemp;
if (SUCCEEDED(hr))
hr = pEnum->QueryInterface(IID_IEnumVARIANT, (void**)ppunkEnum);
if (FAILED(hr))
delete pEnum;
// Return the last result
return hr;
}
/* ------------------------------------------------------------------------- */
int tx_zmodem(s_protinfo *pi, bool caller)
{
int startblk = 64; /* Initial Zmodem block size */
int minblk = 64; /* Minimal Z-protocol block size */
int maxblk = 1024;/* Maximal Z-protocol block size */
int blocklen = 0; /* Length of transmitted blocks */
int goodblk = 0; /* How many blocks we sent w/o ZRPOS'tion :) */
int txwindow = 0; /* Tranmitter window size (0 means streaming) */
int newcnt = 0; /* Count free bytes in receiver's buffer */
int rxbuflen = 0; /* Receiver's max buffer length */
int rxlastpos = 0; /* Receiver's last reported offset */
int beenhere = 0; /* How many times we've been ZRPOS'd same place */
long bytescnt = 0; /* Received bytes(current offset) */
long lastsync = 0; /* Last offset to which we got a ZRPOS */
char zconv = 0; /* Local ZMODEM file conversion request */
char zmanag = 0; /* Local ZMODEM file management request */
char ztrans = 0; /* Local ZMODEM file translation request */
char zexten = 0; /* Local ZMODEM file extended options */
char *txbuf = NULL;/* Buffer with ZMAXBLOCKLEN size */
int zrinitcnt = 0; /* Count received ZRINITs */
int rxflags1 = 0;
int rxflags2 = 0;
int txtries = 0;
int junkcnt = 0;
int initacked = 0; /* TRUE when at least one ZRQINIT was sent */
/* after first ZRINIT was received */
int rc = 0; /* Our return code */
int dtype, n;
int ftype;
char c, *p;
long unsigned crc32;
enum ztxstates txstate;
time_t deadtimer;
log("start %s send", Protocols[state.handshake->protocol]);
DEB((D_PROT, "start %s send", Protocols[state.handshake->protocol]));
/* Set time transfer started at */
if( pi->start_time == 0 )
pi->start_time = time(NULL);
txbuf = (char *)xmalloc(ZMAXBLOCKLEN+1);
zconv = ZCBIN;
maxblk = (state.handshake->protocol == PROT_ZMODEM) ? 1024 : 8192;
/* Set initial block size (default is 128b) */
if( (startblk = conf_number(cf_zmodem_start_block_size)) > 0 )
{
if( startblk%64 || startblk > maxblk || startblk < 64 )
startblk = 256;
} else
startblk = 256;
blocklen = startblk;
txwindow = conf_number(cf_zmodem_tx_window);
Z_Rxwait = ZWAITTIME;
Z_Rxtout = ZRXTIMEOUT;
txstate = ZTX_START;
timer_set(&deadtimer, ZDEADTIMER);
setalarm(Z_Rxtout);
/*
* At zmodem batches send empty netmail packet
* if no real outgoing traffic available
*/
if( !pi->send_left_size && conf_boolean(cf_zmodem_send_dummy_pkt) )
zmodem_add_empty_packet(pi);
while(1)
{
if( timer_expired(deadtimer) )
{
log("brain dead! (abort)");
gotoexit(PRC_LOCALABORTED);
}
if( txstate == ZTX_RQINIT || txstate == ZTX_FINFO
|| txstate == ZTX_EOF || txstate == ZTX_FIN )
{
#ifdef DEBUG
if( txtries ) DEB((D_PROT, "tx_zmodem: try #%d", txtries));
#endif
if( ++txtries > ZMAXTRIES )
{
log("out of tries");
gotoexit(PRC_LOCALABORTED);
}
}
switch(txstate) {
case ZTX_START:
DEB((D_PROT, "tx_zmodem: entering state ZTX_START"));
if( PUTSTR("rz\r") < 0 )
gotoexit(PRC_ERROR);
txtries = 0;
txstate = ZTX_RQINIT;
break;
case ZTX_RQINIT:
DEB((D_PROT, "tx_zmodem: entering state ZTX_RQINIT"));
stohdr(Z_Txhdr, 0L);
if( zshhdr(ZRQINIT, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
setalarm(Z_Rxtout);
txstate = ZTX_RQINITACK;
break;
case ZTX_NEXTFILE:
DEB((D_PROT, "tx_zmodem: entering state ZTX_NEXTFILE"));
if (pi->send) p_tx_fclose(pi);
txtries = 0;
txstate = p_tx_fopen(pi, NULL) ? ZTX_FIN : ZTX_FINFO;
log("nextfile next state: %d", txstate);
break;
case ZTX_FINFO:
DEB((D_PROT, "tx_zmodem: entering state ZTX_FINFO"));
zrinitcnt = 0;
strnxcpy(txbuf, pi->send->net_name, ZMAXFNAME);
p = txbuf + strlen(txbuf) + 1;
sprintf(p, "%ld %lo %lo 0 %ld %ld",
(long)pi->send->bytes_total, (long)pi->send->mod_time,
(long)pi->send->mode, (long)pi->send_left_num,
(long)pi->send_left_size);
DEB((D_PROT, "tx_zmodem: send \"%s\\000%s\"", txbuf, p));
Z_Txhdr[ZF0] = zconv; /* file conversion request */
Z_Txhdr[ZF1] = zmanag; /* file management request */
Z_Txhdr[ZF2] = ztrans; /* file transport request */
Z_Txhdr[ZF3] = zexten;
if( zsbhdr(ZFILE, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
if( zsdata(txbuf, (p - txbuf) + strlen(p), ZCRCW, 0) < 0 )
gotoexit(PRC_ERROR);
setalarm(Z_Rxtout);
txstate = ZTX_FINFOACK;
break;
case ZTX_STARTDATA:
DEB((D_PROT, "tx_zmodem: entering state ZTX_STARTDATA"));
newcnt = rxbuflen;
junkcnt = 0;
stohdr(Z_Txhdr, pi->send->bytes_sent);
if( zsbhdr(ZDATA, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
txstate = ZTX_DATA;
break;
case ZTX_DATA:
DEB((D_PROT, "tx_zmodem: entering state ZTX_DATA"));
timer_set(&deadtimer, ZDEADTIMER);
setalarm(Z_Rxtout); /* Remove annoing timeouts! */
if( (n = p_tx_readfile(txbuf, blocklen, pi)) < 0 )
{
/* error occured, remote wait for DATA */
/* so send null ZCRCE data subpacket */
if( zsdata(txbuf, 0, ZCRCE, 0) < 0 )
gotoexit(PRC_ERROR);
txstate = ZTX_NEXTFILE;
break;
}
if( pi->send->eofseen )
dtype = ZCRCE;
else if( junkcnt > 6 )
dtype = ZCRCW;
else if( bytescnt == lastsync )
dtype = ZCRCW;
else if( rxbuflen && (newcnt -= n) <= 0 )
dtype = ZCRCW;
else if( txwindow && (bytescnt - rxlastpos + n) >= txwindow )
dtype = ZCRCQ;
else
dtype = ZCRCG;
if( (rc = p_info(pi, 0)) )
gotoexit(rc);
if( zsdata(txbuf, n, dtype, pi->send->bytes_sent) < 0 )
gotoexit(PRC_ERROR);
if( ++goodblk > 5 && blocklen*2 <= maxblk )
{
goodblk = 0;
blocklen *= 2;
DEB((D_PROT, "tx_zmodem: new blocklen = %ld byte(s)", blocklen));
}
bytescnt = pi->send->bytes_sent += n;
if( dtype == ZCRCW )
{
junkcnt = 0;
setalarm(Z_Rxtout);
txstate = ZTX_CRCWACK;
break;
}
else if( dtype == ZCRCQ )
{
junkcnt = 0;
setalarm(Z_Rxtout);
txstate = ZTX_CRCQACK;
break;
}
else if( dtype == ZCRCE )
{
txtries = 0;
txstate = ZTX_EOF;
break;
}
if( CHARWAIT(0) )
{
while( (rc = GETCHAR(1)) != ZTIMER )
{
if( rc < 0 )
{
gotoexit(PRC_ERROR);
}
else if( rc == CAN || rc == ZPAD )
{
DEB((D_PROT, "tx_zmodem: got ZPAD or CAN!"));
setalarm(Z_Rxtout);
txstate = ZTX_READCHECK;
break;
}
else if( rc == XOFF || rc == (XOFF|0200) )
{
DEB((D_PROT, "tx_zmodem: got XOFF"));
if( GETCHAR(5) < 0 )
gotoexit(PRC_ERROR);
break;
}
else if( rc == XON || rc == (XON|0200) )
{
DEB((D_PROT, "tx_zmodem: got XON"));
}
else
{
junkcnt++;
DEB((D_PROT, "tx_zmodem: got JUNK = 0x%x (junkcnt = %d)",
rc, junkcnt));
}
} /* end of while( rc != ZTIMER ) */
} /* end of if( CHARWAIT(0) ) */
break;
case ZTX_EOF:
DEB((D_PROT, "tx_zmodem: entering state ZTX_EOF"));
stohdr(Z_Txhdr, pi->send->bytes_sent);
if( zsbhdr(ZEOF, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
setalarm(Z_Rxtout);
txstate = ZTX_EOFACK;
break;
case ZTX_FIN:
DEB((D_PROT, "tx_zmodem: entering state ZTX_FIN"));
stohdr(Z_Txhdr, 0L);
if( zshhdr(ZFIN, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
setalarm(Z_Rxtout);
txstate = ZTX_FINACK;
break;
default:
/* Ignore them all */
break;
} /* end of switch(txstate) */
if( txstate != ZTX_START && txstate != ZTX_RQINIT
&& txstate != ZTX_FINFO && txstate != ZTX_DATA
&& txstate != ZTX_EOF && txstate != ZTX_FIN )
{
switch( ftype = zgethdr(Z_Rxhdr) ) {
case ZCAN:
gotoexit(PRC_REMOTEABORTED);
break;
case ZHANGUP:
case ZEXIT:
gotoexit(PRC_ERROR);
break;
case ZTIMER:
log("time out");
if( txstate == ZTX_READCHECK )
zsdata(txbuf, 0, ZCRCE, 0);
switch(txstate) {
case ZTX_RQINITACK: txstate = ZTX_RQINIT; break;
case ZTX_FINFOACK: txstate = ZTX_FINFO; break;
case ZTX_READCHECK: txstate = ZTX_STARTDATA; break;
case ZTX_CRCWACK: txstate = ZTX_STARTDATA; break;
case ZTX_CRCQACK: txstate = ZTX_STARTDATA; break;
case ZTX_EOFACK: txstate = ZTX_EOF; break;
case ZTX_FINACK: txstate = ZTX_FIN; break;
default: break;
}
break;
case ZERROR:
case ZCRCERR:
/* NAK them all! */
stohdr(Z_Txhdr, 0L);
if( zshhdr(ZNAK, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
break;
case ZRQINIT:
if( txstate == ZTX_RQINITACK )
{
if( Z_Rxhdr[0] == ZCOMMAND )
break;
stohdr(Z_Txhdr, 0L);
if( zshhdr(ZNAK, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
txstate = ZTX_RQINIT;
}
else if( txstate == ZTX_FINFOACK )
{
/* remote is sender - abort */
log("zmodem: remote is sender");
gotoexit(PRC_LOCALABORTED);
}
break;
case ZRINIT:
if( txstate == ZTX_RQINITACK )
{
if( initacked == 0 )
{
/* Be sure ack first ZRINIT */
stohdr(Z_Txhdr, 0L);
if( zshhdr(ZRQINIT, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
initacked = 1;
}
/* Get receiver's options */
rxflags1 = (0377 & Z_Rxhdr[ZF0]);
rxflags2 = (0377 & Z_Rxhdr[ZF1]);
Z_Txfcs32 = (rxflags1 & CANFC32);
Z_Ctlesc |= (rxflags1 & TESCCTL);
rxbuflen = (0377 & Z_Rxhdr[ZP0]);
rxbuflen += ((0377 & Z_Rxhdr[ZP1])<<8);
/* No ZCRCQ if remote doesn't indicate */
/* FDX ability */
if( !(rxflags1 & CANFDX) )
txwindow = 0;
DEB((D_PROT, "tx_zmodem: Z_Txfcs32 = %d Z_Ctlesc = %d",
Z_Txfcs32, Z_Ctlesc));
DEB((D_PROT, "tx_zmodem: rxbuflen = %d blocklen = %d",
rxbuflen, blocklen));
DEB((D_PROT, "tx_zmodem: txwindow = %u",
txwindow));
txstate = ZTX_NEXTFILE;
}
else if( txstate == ZTX_FINFOACK )
{
/* Possible they didn't see */
/* our file information */
if( ++zrinitcnt > 2 )
txstate = ZTX_FINFO;
}
else if( txstate == ZTX_READCHECK
|| txstate == ZTX_CRCQACK
|| txstate == ZTX_CRCWACK )
{
if( txstate == ZTX_READCHECK
|| txstate == ZTX_CRCQACK )
zsdata(txbuf, 0, ZCRCE, 0);
/* Assume file normaly sent ? */
log("assume file normaly sent");
pi->send->status = FSTAT_SUCCESS;
txstate = ZTX_NEXTFILE;
}
else if( txstate == ZTX_EOFACK )
{
/* ok, send next */
pi->send->status = FSTAT_SUCCESS;
txstate = ZTX_NEXTFILE;
}
else if( txstate == ZTX_FINACK )
{
/* Possible we should ignore */
/* first ZRINIT. Because they */
/* didn't see our first ZFIN */
/* But I'm soo lazy .. :)) */
txstate = ZTX_FIN;
}
break;
case ZACK:
if( txstate == ZTX_CRCWACK )
{
rxlastpos = Z_Rxpos;
if( pi->send->bytes_sent == Z_Rxpos )
txstate = ZTX_STARTDATA;
}
else if( txstate == ZTX_READCHECK
|| txstate == ZTX_CRCQACK )
{
rxlastpos = Z_Rxpos;
txstate = ZTX_DATA;
}
break;
case ZSKIP:
if( txstate == ZTX_FINFOACK
|| txstate == ZTX_READCHECK
|| txstate == ZTX_CRCQACK
|| txstate == ZTX_CRCWACK
|| txstate == ZTX_EOFACK )
{
if( txstate == ZTX_READCHECK
|| txstate == ZTX_CRCQACK )
zsdata(txbuf, 0, ZCRCE, 0);
if( txstate == ZTX_READCHECK )
CLEAROUT();
pi->send->status = FSTAT_SKIPPED;
log("remote side skipped file");
txstate = ZTX_NEXTFILE;
}
break;
case ZFIN:
/* BUG!BUG!BUG!BUG!BUG!BUG!BUG!BUG!BUG! */
/* BUG!BUG!BUG!BUG!BUG!BUG!BUG!BUG!BUG! */
log(" BUG!BUG!BUG!BUG!BUG!BUG!BUG!BUG!BUG! ");
if( txstate == ZTX_FINACK )
{
if( PUTSTR("OO") == 0 )
FLUSHOUT();
gotoexit(PRC_NOERROR);
}
break;
case ZRPOS:
if( txstate == ZTX_FINFOACK
|| txstate == ZTX_READCHECK
|| txstate == ZTX_CRCQACK
|| txstate == ZTX_CRCWACK
|| txstate == ZTX_EOFACK )
{
rxlastpos = Z_Rxpos;
/* Clear modem buffers */
/* if( txstate != FINFOACK ) SENDBREAK(); */
if( txstate == ZTX_READCHECK ) CLEAROUT();
if( txstate == ZTX_READCHECK
|| txstate == ZTX_CRCQACK )
{
if( zsdata(txbuf, 0, ZCRCE, 0) < 0 )
gotoexit(PRC_ERROR);
}
/* Reset EOF flag! */
pi->send->eofseen = FALSE;
/* Check pos */
if( (Z_Rxpos || txstate != ZTX_FINFOACK)
&& p_tx_rewind(pi, Z_Rxpos) )
{
logerr("can't send file from requested position");
/* Open next file for send */
txstate = ZTX_NEXTFILE;
break;
}
if( txstate == ZTX_FINFOACK )
{
if( Z_Rxpos )
{
log("resyncing at offset %d", Z_Rxpos);
pi->send->bytes_skipped = Z_Rxpos;
}
}
else if( txstate == ZTX_READCHECK
|| txstate == ZTX_CRCWACK
|| txstate == ZTX_CRCQACK )
{
goodblk = 0;
if( lastsync >= Z_Rxpos && ++beenhere > 4 )
if( blocklen > minblk )
{
blocklen /= 2;
DEB((D_PROT, "tx_zmodem: falldown to %ld BlockLen", blocklen));
}
}
lastsync = bytescnt = pi->send->bytes_sent = Z_Rxpos;
if( txstate == ZTX_FINFOACK )
--lastsync;
txstate = ZTX_STARTDATA;
}
break;
case ZNAK:
switch(txstate) {
case ZTX_RQINITACK: txstate = ZTX_RQINIT; break;
case ZTX_FINFOACK: txstate = ZTX_FINFO; break;
case ZTX_EOFACK: txstate = ZTX_EOF; break;
case ZTX_FINACK: txstate = ZTX_FIN; break;
default: break;
}
break;
case ZCRC:
if( txstate == ZTX_FINFOACK )
{
log(" Send file's CRC-32 ");
crc32 = 0xFFFFFFFFL;
while( ((c = getc(pi->send->fp)) != EOF) && --Z_Rxpos )
crc32 = updcrc32(c, crc32);
crc32 = ~crc32;
clearerr(pi->send->fp); /* Clear EOF */
fseek(pi->send->fp, 0L, 0);
stohdr(Z_Txhdr, crc32);
if( zsbhdr(ZCRC, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
}
break;
case ZCHALLENGE:
if( txstate == ZTX_RQINITACK )
{
/* Echo receiver's challenge number */
stohdr(Z_Txhdr, Z_Rxpos);
if( zshhdr(ZACK, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
txstate = ZTX_RQINIT;
}
break;
case ZCOMMAND:
if( txstate == ZTX_RQINITACK )
{
txstate = ZTX_RQINIT;
}
break;
case ZABORT:
log("remote requested for session abort");
stohdr(Z_Txhdr, 0L);
if( zshhdr(ZFIN, Z_Txhdr) < 0 )
gotoexit(PRC_ERROR);
gotoexit(PRC_REMOTEABORTED);
break;
case ZFERR:
if( txstate == ZTX_FINFOACK
|| txstate == ZTX_READCHECK
|| txstate == ZTX_CRCWACK
|| txstate == ZTX_CRCQACK
|| txstate == ZTX_EOFACK )
{
if( txstate == ZTX_READCHECK
|| txstate == ZTX_CRCQACK )
{
if( zsdata(txbuf, 0, ZCRCE, 0) < 0 )
gotoexit(PRC_ERROR);
}
pi->send->status = FSTAT_REFUSED;
log("remote side refused file");
txstate = ZTX_NEXTFILE;
}
break;
default:
log("got unexpected frame %d", ftype);
break;
} /* end of switch(hdr) */
} /* end of if */
} /* end of while */
exit:
DEB((D_PROT, "tx_zmodem: SEND exit = %d", rc));
setalarm(0);
if (pi->send) p_tx_fclose(pi);
if( txbuf ) {
free(txbuf);
txbuf = NULL;
}
return(rc);
}
HRESULT CPigEngine::get_EventLog(IAGCEventLogger** ppEventLogger)
{
CLEAROUT(ppEventLogger, (IAGCEventLogger*)NULL);
(*ppEventLogger = m_spEventLogger)->AddRef();
return S_OK;
}
/*-------------------------------------------------------------------------
* CServiceModule::get_EventLog
*-------------------------------------------------------------------------
* Purpose:
* Gets the previously created event logger object.
*
*/
HRESULT CServiceModule::get_EventLog(IAGCEventLogger** ppEventLogger)
{
CLEAROUT(ppEventLogger, (IAGCEventLogger*)NULL);
(*ppEventLogger = m_spEventLogger)->AddRef();
return S_OK;
}
