CBonTuner::~CBonTuner()
{
// 開かれてる場合は閉じる
CloseTuner();
// クリティカルセクション削除
::DeleteCriticalSection(&m_CriticalSection);
m_pThis = NULL;
}
void cProxyClient::Release(void)
{
if (m_bTuner)
CloseTuner();
makePacket(eRelease);
m_bRereased = TRUE;
{
LOCK(Lock_Global);
InstanceList.remove(this);
}
delete this;
}
cProxyClient::~cProxyClient()
{
if (!m_bRereased)
{
if (m_bTuner)
CloseTuner();
makePacket(eRelease);
}
m_Error.Set();
// if (m_iEndCount != -1)
// SleepLock(3);
if (m_hThread != 0)
::pthread_join(m_hThread, NULL);
int i;
{
LOCK(m_writeLock);
for (i = 0; i < 8; i++)
{
if (m_pBuf[i] != NULL)
delete[] m_pBuf[i];
}
::memset(m_pBuf, 0, sizeof(m_pBuf));
TsFlush();
if (m_LastBuff != NULL)
{
delete m_LastBuff;
m_LastBuff = NULL;
}
}
for (i = 0; i < ebResNum; i++)
delete m_bResEvent[i];
for (i = 0; i < edwResNum; i++)
delete m_dwResEvent[i];
for (i = 0; i < epResNum; i++)
delete m_pResEvent[i];
::pthread_cond_destroy(&m_c);
::pthread_mutex_destroy(&m_m);
if (m_s != INVALID_SOCKET)
::close(m_s);
}
CBonDriver_TSTask::~CBonDriver_TSTask()
{
CloseTuner();
}
// チャンネル設定
const BOOL CBonTuner::SetChannel(const DWORD dwSpace, const DWORD dwChannel)
{
// 有効なチャンネルか
if(dwSpace > 0 || (dwChannel >= PIPE_NODE_NUM))
return FALSE;
// 一旦クローズ
CloseTuner();
// バッファ確保
if(!(m_pIoReqBuff = AllocIoReqBuff(ASYNCBUFFSIZE))){
return FALSE;
}
// バッファ位置同期
m_pIoPushReq = m_pIoReqBuff;
m_pIoPopReq = m_pIoReqBuff;
m_pIoGetReq = m_pIoReqBuff;
m_dwBusyReqNum = 0;
m_dwReadyReqNum = 0;
try{
// ドライバオープン
TCHAR szName[MAX_PATH];
::wsprintf(szName, PIPE_NAME, dwChannel);
m_hPipe = ::CreateNamedPipe(szName, PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED, PIPE_TYPE_BYTE, 1,
sizeof(m_pIoReqBuff->RxdBuff), sizeof(m_pIoReqBuff->RxdBuff), 3000, NULL);
if (m_hPipe == INVALID_HANDLE_VALUE) {
::OutputDebugString(TEXT("BonDriver_Pipe: CBonTuner::OpenTuner() CreateNamedPipe error\n"));
throw 1UL;
}
// イベント作成
if(!(m_hOnStreamEvent = ::CreateEvent(NULL, FALSE, FALSE, NULL)))throw 2UL;
// スレッド起動
DWORD dwPushIoThreadID = 0UL, dwPopIoThreadID = 0UL;
m_hPushIoThread = ::CreateThread(NULL, 0UL, CBonTuner::PushIoThread, this, CREATE_SUSPENDED, &dwPopIoThreadID);
m_hPopIoThread = ::CreateThread(NULL, 0UL, CBonTuner::PopIoThread, this, CREATE_SUSPENDED, &dwPushIoThreadID);
if(!m_hPushIoThread || !m_hPopIoThread){
if(m_hPushIoThread){
::TerminateThread(m_hPushIoThread, 0UL);
::CloseHandle(m_hPushIoThread);
m_hPushIoThread = NULL;
}
if(m_hPopIoThread){
::TerminateThread(m_hPopIoThread, 0UL);
::CloseHandle(m_hPopIoThread);
m_hPopIoThread = NULL;
}
throw 3UL;
}
// スレッド開始
m_bLoopIoThread = TRUE;
if(::ResumeThread(m_hPushIoThread) == 0xFFFFFFFFUL || ::ResumeThread(m_hPopIoThread) == 0xFFFFFFFFUL)throw 4UL;
// ミューテックス作成
if(!(m_hMutex = ::CreateMutex(NULL, TRUE, MUTEX_NAME)))throw 5UL;
}
catch(const DWORD dwErrorStep){
// エラー発生
TCHAR szDebugOut[1024];
::wsprintf(szDebugOut, TEXT("BonDriver_Pipe: CBonTuner::OpenTuner() dwErrorStep = %lu\n"), dwErrorStep);
::OutputDebugString(szDebugOut);
CloseTuner();
return FALSE;
}
// チャンネル情報更新
m_dwCurSpace = dwSpace;
m_dwCurChannel = dwChannel;
// TSデータパージ
PurgeTsStream();
return TRUE;
}
vector<CTunerBankCtrl::CHECK_RESULT> CTunerBankCtrl::Check(vector<DWORD>* startedReserveIDList)
{
vector<CHECK_RESULT> retList;
if( this->hTunerProcess && WaitForSingleObject(this->hTunerProcess, 0) != WAIT_TIMEOUT ){
//チューナが予期せず閉じられた
CloseTuner();
this->specialState = TR_IDLE;
//TR_IDLEでない全予約を葬る
for( map<DWORD, TUNER_RESERVE>::const_iterator itr = this->reserveMap.begin(); itr != this->reserveMap.end(); ){
if( itr->second.state != TR_IDLE ){
CHECK_RESULT ret;
ret.type = CHECK_ERR_REC;
ret.reserveID = itr->first;
retList.push_back(ret);
this->reserveMap.erase(itr++);
}else{
itr++;
}
}
}
CWatchBlock watchBlock(&this->watchContext);
CSendCtrlCmd ctrlCmd;
if( this->hTunerProcess ){
//チューナ起動時にはこれを再度呼ぶこと
ctrlCmd.SetPipeSetting(CMD2_VIEW_CTRL_WAIT_CONNECT, CMD2_VIEW_CTRL_PIPE, this->tunerPid);
}
if( this->specialState == TR_EPGCAP ){
DWORD status;
if( ctrlCmd.SendViewGetStatus(&status) == CMD_SUCCESS ){
if( status != VIEW_APP_ST_GET_EPG ){
//取得終わった
OutputDebugString(L"epg end\r\n");
CloseTuner();
this->specialState = TR_IDLE;
}
}else{
//エラー
OutputDebugString(L"epg err\r\n");
CloseTuner();
this->specialState = TR_IDLE;
}
}else if( this->specialState == TR_NWTV ){
//ネットワークモードではGUIキープできないのでBonDriverが変更されるかもしれない
//BonDriverが変更されたチューナはこのバンクの管理下に置けないので、ネットワークモードを解除する
wstring bonDriver;
if( ctrlCmd.SendViewGetBonDrivere(&bonDriver) == CMD_SUCCESS && CompareNoCase(bonDriver, this->bonFileName) != 0 ){
if( ctrlCmd.SendViewSetID(-1) == CMD_SUCCESS ){
CBlockLock lock(&this->watchContext.lock);
CloseHandle(this->hTunerProcess);
this->hTunerProcess = NULL;
this->specialState = TR_IDLE;
}else{
//ID剥奪に失敗したので消えてもらうしかない
CloseNWTV();
}
//TODO: 汎用のログ用メッセージが存在しないので、やむを得ずNOTIFY_UPDATE_REC_ENDで警告する
this->notifyManager.AddNotifyMsg(NOTIFY_UPDATE_REC_END,
L"BonDriverが変更されたためNetworkモードを解除しました\r\n変更したBonDriverに録画の予定がないか注意してください");
}
}else if( this->hTunerProcess && this->tunerChLocked == false ){
//GUIキープされていないのでBonDriverが変更されるかもしれない
wstring bonDriver;
if( ctrlCmd.SendViewGetBonDrivere(&bonDriver) == CMD_SUCCESS && CompareNoCase(bonDriver, this->bonFileName) != 0 ){
if( ctrlCmd.SendViewSetID(-1) == CMD_SUCCESS ){
CBlockLock lock(&this->watchContext.lock);
CloseHandle(this->hTunerProcess);
this->hTunerProcess = NULL;
}else{
//ID剥奪に失敗したので消えてもらうしかない
CloseTuner();
}
//TR_IDLEでない全予約を葬る
for( map<DWORD, TUNER_RESERVE>::const_iterator itr = this->reserveMap.begin(); itr != this->reserveMap.end(); ){
if( itr->second.state != TR_IDLE ){
CHECK_RESULT ret;
ret.type = CHECK_ERR_REC;
ret.reserveID = itr->first;
retList.push_back(ret);
this->reserveMap.erase(itr++);
}else{
itr++;
}
}
}
}
this->delayTime = 0;
this->epgCapDelayTime = 0;
if( this->hTunerProcess && this->specialState != TR_NWTV ){
//PC時計との誤差取得
int delaySec;
if( ctrlCmd.SendViewGetDelay(&delaySec) == CMD_SUCCESS ){
//誤った値を掴んでおかしなことにならないよう、EPG取得中の値は状態遷移の参考にしない
if( this->specialState == TR_EPGCAP ){
this->epgCapDelayTime = delaySec * I64_1SEC;
}else{
this->delayTime = delaySec * I64_1SEC;
}
}
}
__int64 now = GetNowI64Time() + this->delayTime;
//終了時間を過ぎた予約を回収し、TR_IDLE->TR_READY以外の遷移をする
vector<pair<__int64, DWORD>> idleList;
bool ngResetLock = false;
for( map<DWORD, TUNER_RESERVE>::iterator itrRes = this->reserveMap.begin(); itrRes != this->reserveMap.end(); ){
TUNER_RESERVE& r = itrRes->second;
CHECK_RESULT ret;
ret.type = 0;
switch( r.state ){
case TR_IDLE:
if( r.startTime + r.endMargin + r.durationSecond * I64_1SEC < now ){
ret.type = CHECK_ERR_PASS;
}
//開始順が秒精度なので、前後関係を確実にするため開始時間は必ず秒精度で扱う
else if( (r.startTime - r.startMargin - this->recWakeTime) / I64_1SEC < now / I64_1SEC ){
//録画開始recWakeTime前〜
idleList.push_back(std::make_pair(r.startOrder, r.reserveID));
}
break;
case TR_READY:
if( r.startTime + r.endMargin + r.durationSecond * I64_1SEC < now ){
for( int i = 0; i < 2; i++ ){
if( r.ctrlID[i] != 0 ){
ctrlCmd.SendViewDeleteCtrl(r.ctrlID[i]);
}
}
ret.type = CHECK_ERR_PASS;
}
//パイプコマンドにはチャンネル変更の完了を調べる仕組みがないので、妥当な時間だけ待つ
else if( GetTickCount() - this->tunerChChgTick > 5000 && r.startTime - r.startMargin < now ){
//録画開始〜
if( RecStart(r, now) ){
//途中から開始されたか
r.notStartHead = r.startTime - r.startMargin + 60 * I64_1SEC < now;
r.appendPgInfo = false;
r.savedPgInfo = false;
r.state = TR_REC;
if( r.recMode == RECMODE_VIEW ){
//視聴予約でない予約が1つでもあれば「視聴モード」にしない
map<DWORD, TUNER_RESERVE>::const_iterator itr;
for( itr = this->reserveMap.begin(); itr != this->reserveMap.end(); itr++ ){
if( itr->second.state != TR_IDLE && itr->second.recMode != RECMODE_VIEW ){
break;
}
}
if( itr == this->reserveMap.end() ){
//「視聴モード」にするとGUIキープが解除されてしまうためチャンネルを把握することはできない
ctrlCmd.SendViewSetStandbyRec(2);
this->tunerChLocked = false;
if( this->recView ){
ctrlCmd.SendViewExecViewApp();
}
}
}
if( startedReserveIDList ){
startedReserveIDList->push_back(r.reserveID);
}
}else{
//開始できなかった
ret.type = CHECK_ERR_RECSTART;
}
}
break;
case TR_REC:
{
//ステータス確認
DWORD status;
if( r.recMode != RECMODE_VIEW && ctrlCmd.SendViewGetStatus(&status) == CMD_SUCCESS && status != VIEW_APP_ST_REC ){
//キャンセルされた？
ret.type = CHECK_ERR_REC;
this->tunerResetLock = true;
}else if( r.startTime + r.endMargin + r.durationSecond * I64_1SEC < now ){
ret.type = CHECK_ERR_REC;
ret.continueRec = false;
ret.drops = 0;
ret.scrambles = 0;
bool isMainCtrl = true;
for( int i = 0; i < 2; i++ ){
if( r.ctrlID[i] != 0 ){
if( r.recMode == RECMODE_VIEW ){
if( isMainCtrl ){
ret.type = CHECK_END;
}
}else{
SET_CTRL_REC_STOP_PARAM param;
param.ctrlID = r.ctrlID[i];
param.saveErrLog = this->saveErrLog;
SET_CTRL_REC_STOP_RES_PARAM resVal;
if( ctrlCmd.SendViewStopRec(param, &resVal) != CMD_SUCCESS ){
if( isMainCtrl ){
ret.type = CHECK_ERR_RECEND;
}
}else if( isMainCtrl ){
ret.type = resVal.subRecFlag ? CHECK_END_END_SUBREC :
r.notStartHead ? CHECK_END_NOT_START_HEAD :
r.savedPgInfo == false ? CHECK_END_NOT_FIND_PF : CHECK_END;
ret.recFilePath = resVal.recFilePath;
ret.drops = resVal.drop;
ret.scrambles = resVal.scramble;
ret.epgStartTime = r.epgStartTime;
ret.epgEventName = r.epgEventName;
}
}
ctrlCmd.SendViewDeleteCtrl(r.ctrlID[i]);
isMainCtrl = false;
}
}
//録画終了に伴ってGUIキープが解除されたかもしれない
this->tunerResetLock = true;
}else{
//番組情報確認
if( r.savedPgInfo == false && r.recMode != RECMODE_VIEW ){
GET_EPG_PF_INFO_PARAM val;
val.ONID = r.onid;
val.TSID = r.tsid;
val.SID = r.sid;
val.pfNextFlag = FALSE;
EPGDB_EVENT_INFO resVal;
if( ctrlCmd.SendViewGetEventPF(&val, &resVal) == CMD_SUCCESS &&
resVal.StartTimeFlag && resVal.DurationFlag &&
ConvertI64Time(resVal.start_time) <= r.startTime + 30 * I64_1SEC &&
r.startTime + 30 * I64_1SEC < ConvertI64Time(resVal.start_time) + resVal.durationSec * I64_1SEC &&
(r.eid == 0xFFFF || r.eid == resVal.event_id) ){
//開始時間から30秒は過ぎているのでこの番組情報が録画中のもののはず
r.savedPgInfo = true;
r.epgStartTime = resVal.start_time;
r.epgEventName = resVal.shortInfo ? resVal.shortInfo->event_name : L"";
//ごく稀にAPR(改行)を含むため
Replace(r.epgEventName, L"\r\n", L"");
if( this->saveProgramInfo ){
for( int i = 0; i < 2; i++ ){
wstring recPath;
if( r.ctrlID[i] != 0 && ctrlCmd.SendViewGetRecFilePath(r.ctrlID[i], &recPath) == CMD_SUCCESS ){
SaveProgramInfo(recPath.c_str(), resVal, r.appendPgInfo);
}
}
}
}
}
//まだ録画中の予約があるのでGUIキープを再設定してはいけない
ngResetLock = true;
}
}
break;
}
if( ret.type != 0 ){
ret.reserveID = itrRes->first;
retList.push_back(ret);
this->reserveMap.erase(itrRes++);
}else{
itrRes++;
}
}
//TR_IDLE->TR_READYの遷移を待つ予約を開始順に並べる
std::sort(idleList.begin(), idleList.end());
//TR_IDLE->TR_READY(TR_REC)の遷移をする
for( vector<pair<__int64, DWORD>>::const_iterator itrIdle = idleList.begin(); itrIdle != idleList.end(); itrIdle++ ){
map<DWORD, TUNER_RESERVE>::iterator itrRes = this->reserveMap.find(itrIdle->second);
TUNER_RESERVE& r = itrRes->second;
CHECK_RESULT ret;
ret.type = 0;
if( this->hTunerProcess == NULL ){
//チューナを起動する
SET_CH_INFO initCh;
initCh.ONID = r.onid;
initCh.TSID = r.tsid;
initCh.SID = r.sid;
initCh.useSID = TRUE;
initCh.useBonCh = FALSE;
bool nwUdpTcp = this->recNW || r.recMode == RECMODE_VIEW;
if( OpenTuner(this->recMinWake, nwUdpTcp, nwUdpTcp, true, &initCh) ){
this->tunerONID = r.onid;
this->tunerTSID = r.tsid;
this->tunerChLocked = true;
this->tunerResetLock = false;
this->tunerChChgTick = GetTickCount();
this->notifyManager.AddNotifyMsg(NOTIFY_UPDATE_PRE_REC_START, this->bonFileName);
ctrlCmd.SetPipeSetting(CMD2_VIEW_CTRL_WAIT_CONNECT, CMD2_VIEW_CTRL_PIPE, this->tunerPid);
r.retryOpenCount = 0;
}else if( ++r.retryOpenCount >= 4 || r.retryOpenCount == 2 && CloseOtherTuner() == false ){
//試行2回→他チューナ終了成功時さらに2回→起動できなかった
ret.type = CHECK_ERR_OPEN;
}
}else{
r.retryOpenCount = 0;
}
if( this->hTunerProcess && (r.startTime - r.startMargin) / I64_1SEC - READY_MARGIN < now / I64_1SEC ){
//録画開始READY_MARGIN秒前〜
//原作では録画制御作成は通常録画時60秒前、割り込み録画時15秒前だが
//作成を前倒しする必要は特にないのと、チャンネル変更からEIT[p/f]取得までの時間を確保できるようこの秒数にした
if( this->specialState == TR_EPGCAP ){
//EPG取得をキャンセル(遷移中断)
OutputDebugString(L"epg cancel\r\n");
//CSendCtrlCmd::SendViewEpgCapStop()は送らない(即座にチューナ閉じるので意味がないため)
CloseTuner();
this->specialState = TR_IDLE;
break;
}else if( this->specialState == TR_NWTV ){
//ネットワークモードを解除
wstring bonDriver;
DWORD status;
if( ctrlCmd.SendViewGetBonDrivere(&bonDriver) == CMD_SUCCESS && CompareNoCase(bonDriver, this->bonFileName) == 0 &&
ctrlCmd.SendViewGetStatus(&status) == CMD_SUCCESS && (status == VIEW_APP_ST_NORMAL || status == VIEW_APP_ST_ERR_CH_CHG) ){
//プロセスを引き継ぐ
this->tunerONID = r.onid;
this->tunerTSID = r.tsid;
this->tunerChLocked = false;
this->tunerResetLock = false;
this->specialState = TR_IDLE;
}else{
//ネットワークモード終了(遷移中断)
CloseNWTV();
break;
}
}
if( this->tunerONID != r.onid || this->tunerTSID != r.tsid ){
//チャンネル違うので、TR_IDLEでない全予約の優先度を比べる
map<DWORD, TUNER_RESERVE>::const_iterator itr;
for( itr = this->reserveMap.begin(); itr != this->reserveMap.end(); itr++ ){
if( itr->second.state != TR_IDLE && itr->second.effectivePriority < r.effectivePriority ){
break;
}
}
if( itr == this->reserveMap.end() ){
//TR_IDLEでない全予約は自分よりも弱いので葬る
for( itr = this->reserveMap.begin(); itr != this->reserveMap.end(); ){
if( itr->second.state != TR_IDLE ){
CHECK_RESULT retOther;
retOther.type = CHECK_ERR_REC;
retOther.reserveID = itr->first;
retOther.continueRec = false;
retOther.drops = 0;
retOther.scrambles = 0;
bool isMainCtrl = true;
for( int i = 0; i < 2; i++ ){
if( itr->second.ctrlID[i] != 0 ){
if( itr->second.state == TR_REC ){
if( isMainCtrl ){
retOther.type = CHECK_END_NEXT_START_END;
}
if( itr->second.recMode != RECMODE_VIEW ){
SET_CTRL_REC_STOP_PARAM param;
param.ctrlID = itr->second.ctrlID[i];
param.saveErrLog = this->saveErrLog;
SET_CTRL_REC_STOP_RES_PARAM resVal;
if( ctrlCmd.SendViewStopRec(param, &resVal) != CMD_SUCCESS ){
if( isMainCtrl ){
retOther.type = CHECK_ERR_RECEND;
}
}else if( isMainCtrl ){
retOther.recFilePath = resVal.recFilePath;
retOther.drops = resVal.drop;
retOther.scrambles = resVal.scramble;
}
}
}
ctrlCmd.SendViewDeleteCtrl(itr->second.ctrlID[i]);
isMainCtrl = false;
}
}
retList.push_back(retOther);
this->reserveMap.erase(itr++);
}else{
itr++;
}
}
this->tunerONID = r.onid;
this->tunerTSID = r.tsid;
this->tunerChLocked = false;
this->tunerResetLock = false;
}
}
if( this->tunerONID == r.onid && this->tunerTSID == r.tsid ){
if( this->tunerChLocked == false ){
//チャンネル変更
SET_CH_INFO chgCh;
chgCh.ONID = r.onid;
chgCh.TSID = r.tsid;
chgCh.SID = r.sid;
chgCh.useSID = TRUE;
chgCh.useBonCh = FALSE;
//「予約録画待機中」
ctrlCmd.SendViewSetStandbyRec(1);
if( ctrlCmd.SendViewSetCh(&chgCh) == CMD_SUCCESS ){
this->tunerChLocked = true;
this->tunerResetLock = false;
this->tunerChChgTick = GetTickCount();
}
}
if( this->tunerChLocked ){
//同一チャンネルなので録画制御を作成できる
bool continueRec = false;
for( map<DWORD, TUNER_RESERVE>::const_iterator itr = this->reserveMap.begin(); itr != this->reserveMap.end(); itr++ ){
if( itr->second.continueRecFlag &&
itr->second.state == TR_REC &&
itr->second.sid == r.sid &&
itr->second.recMode != RECMODE_VIEW &&
itr->second.recMode == r.recMode &&
itr->second.enableCaption == r.enableCaption &&
itr->second.enableData == r.enableData &&
itr->second.partialRecMode == r.partialRecMode ){
//連続録画なので、同一制御IDで録画開始されたことにする。TR_RECまで遷移するので注意
r.state = TR_REC;
r.ctrlID[0] = itr->second.ctrlID[0];
r.ctrlID[1] = itr->second.ctrlID[1];
r.notStartHead = r.startTime - r.startMargin + 60 * I64_1SEC < now;
r.appendPgInfo = itr->second.appendPgInfo || itr->second.savedPgInfo;
r.savedPgInfo = false;
//引継ぎ元を葬る
CHECK_RESULT retOther;
retOther.type = CHECK_ERR_REC;
retOther.reserveID = itr->first;
retOther.continueRec = true;
retOther.drops = 0;
retOther.scrambles = 0;
for( int i = 0; i < 2; i++ ){
if( itr->second.ctrlID[i] != 0 ){
if( ctrlCmd.SendViewGetRecFilePath(itr->second.ctrlID[i], &retOther.recFilePath) == CMD_SUCCESS ){
retOther.type = itr->second.notStartHead ? CHECK_END_NOT_START_HEAD :
itr->second.savedPgInfo == false ? CHECK_END_NOT_FIND_PF : CHECK_END;
retOther.epgStartTime = itr->second.epgStartTime;
retOther.epgEventName = itr->second.epgEventName;
}
break;
}
}
retList.push_back(retOther);
this->reserveMap.erase(itr);
continueRec = true;
break;
}
}
if( continueRec == false ){
if( CreateCtrl(&r.ctrlID[0], &r.ctrlID[1], r) ){
r.state = TR_READY;
}else{
//作成できなかった
ret.type = CHECK_ERR_CTRL;
}
}
}
}
}
if( ret.type != 0 ){
ret.reserveID = itrRes->first;
retList.push_back(ret);
this->reserveMap.erase(itrRes);
}
}
if( IsNeedOpenTuner() == false ){
//チューナが必要なくなった
CloseTuner();
}
if( this->hTunerProcess && this->specialState == TR_IDLE && this->tunerResetLock ){
if( ngResetLock == false ){
//「予約録画待機中」
ctrlCmd.SendViewSetStandbyRec(1);
}
this->tunerResetLock = false;
}
return retList;
}
DWORD cProxyServer::Process()
{
HANDLE hThread[2];
hThread[0] = ::CreateThread(NULL, 0, cProxyServer::Sender, this, 0, NULL);
if (hThread[0] == NULL)
return 1;
::SetThreadPriority(hThread[0], g_ThreadPrioritySender);
hThread[1] = ::CreateThread(NULL, 0, cProxyServer::Receiver, this, 0, NULL);
if (hThread[1] == NULL)
{
m_Error.Set();
::WaitForSingleObject(hThread[0], INFINITE);
::CloseHandle(hThread[0]);
return 2;
}
HANDLE h[3] = { m_Error, m_fifoRecv.GetEventHandle(), g_ShutdownEvent };
for (;;)
{
DWORD dwRet = ::WaitForMultipleObjects(3, h, FALSE, INFINITE);
switch (dwRet)
{
case WAIT_OBJECT_0:
goto end;
case WAIT_OBJECT_0 + 1:
{
#ifdef STRICT_LOCK
LOCK(g_Lock);
#endif
cPacketHolder *pPh;
m_fifoRecv.Pop(&pPh);
switch (pPh->GetCommand())
{
case eSelectBonDriver:
{
if (pPh->GetBodyLength() <= sizeof(char))
makePacket(eSelectBonDriver, FALSE);
else
{
LPCSTR p = (LPCSTR)(pPh->m_pPacket->payload);
if (::strlen(p) > (sizeof(m_strBonDriver) - 1))
makePacket(eSelectBonDriver, FALSE);
else
{
BOOL bFind = FALSE;
#ifndef STRICT_LOCK
LOCK(g_Lock);
#endif
for (std::list<cProxyServer *>::iterator it = g_InstanceList.begin(); it != g_InstanceList.end(); ++it)
{
if (::strcmp(p, (*it)->m_strBonDriver) == 0)
{
bFind = TRUE;
m_hModule = (*it)->m_hModule;
::strcpy(m_strBonDriver, (*it)->m_strBonDriver);
m_pIBon = (*it)->m_pIBon; // (*it)->m_pIBonがNULLの可能性はゼロではない
m_pIBon2 = (*it)->m_pIBon2;
m_pIBon3 = (*it)->m_pIBon3;
break;
}
}
BOOL bSuccess;
if (!bFind)
{
bSuccess = SelectBonDriver(p);
if (bSuccess)
{
g_InstanceList.push_back(this);
::strcpy(m_strBonDriver, p);
}
}
else
{
g_InstanceList.push_back(this);
bSuccess = TRUE;
}
makePacket(eSelectBonDriver, bSuccess);
#ifdef HAVE_UI
if (bSuccess)
::InvalidateRect(g_hWnd, NULL, TRUE);
#endif
}
}
break;
}
case eCreateBonDriver:
{
if (m_pIBon == NULL)
{
BOOL bFind = FALSE;
BOOL bLoop = FALSE;
{
#ifndef STRICT_LOCK
LOCK(g_Lock);
#endif
for (std::list<cProxyServer *>::iterator it = g_InstanceList.begin(); it != g_InstanceList.end(); ++it)
{
if (*it == this)
continue;
if (m_hModule == (*it)->m_hModule)
{
if ((*it)->m_pIBon != NULL)
{
bFind = TRUE; // ここに来るのはかなりのレアケースのハズ
m_pIBon = (*it)->m_pIBon;
m_pIBon2 = (*it)->m_pIBon2;
m_pIBon3 = (*it)->m_pIBon3;
break;
}
else
{
// ここに来るのは上より更にレアケース、あるいはクライアントが
// BonDriver_Proxy.dllを要求し、サーバ側のBonDriver_Proxy.dllも
// 同じサーバに対して自分自身を要求する無限ループ状態だけのハズ
// なお、STRICT_LOCKが定義してある場合は、そもそもデッドロックを
// 起こすので、後者の状況は発生しない
// 気休めの雑なチェック
if (!::_memicmp(m_strBonDriver, "BonDriver_Proxy", 15))
{
bLoop = TRUE;
break;
}
// 無限ループ状態以外の場合は一応リストの最後まで検索してみて、
// それでも見つからなかったらCreateBonDriver()をやらせてみる
}
}
}
}
if (!bFind && !bLoop)
{
if ((CreateBonDriver() != NULL) && (m_pIBon2 != NULL))
makePacket(eCreateBonDriver, TRUE);
else
{
makePacket(eCreateBonDriver, FALSE);
m_Error.Set();
}
}
else
{
if (!bLoop)
makePacket(eCreateBonDriver, TRUE);
else
{
makePacket(eCreateBonDriver, FALSE);
m_Error.Set();
}
}
}
else
makePacket(eCreateBonDriver, TRUE);
break;
}
case eOpenTuner:
{
BOOL bFind = FALSE;
{
#ifndef STRICT_LOCK
LOCK(g_Lock);
#endif
for (std::list<cProxyServer *>::iterator it = g_InstanceList.begin(); it != g_InstanceList.end(); ++it)
{
if (*it == this)
continue;
if ((m_pIBon != NULL) && (m_pIBon == (*it)->m_pIBon))
{
if ((*it)->m_bTunerOpen)
{
bFind = TRUE;
m_bTunerOpen = TRUE;
break;
}
}
}
}
if (!bFind)
m_bTunerOpen = OpenTuner();
makePacket(eOpenTuner, m_bTunerOpen);
break;
}
case eCloseTuner:
{
BOOL bFind = FALSE;
{
#ifndef STRICT_LOCK
LOCK(g_Lock);
#endif
for (std::list<cProxyServer *>::iterator it = g_InstanceList.begin(); it != g_InstanceList.end(); ++it)
{
if (*it == this)
continue;
if ((m_pIBon != NULL) && (m_pIBon == (*it)->m_pIBon))
{
if ((*it)->m_bTunerOpen)
{
bFind = TRUE;
break;
}
}
}
}
if (!bFind)
{
if (m_hTsRead)
{
m_pTsReaderArg->StopTsRead = TRUE;
::WaitForSingleObject(m_hTsRead, INFINITE);
::CloseHandle(m_hTsRead);
delete m_pTsReaderArg;
}
CloseTuner();
}
else
{
if (m_hTsRead)
{
#ifndef STRICT_LOCK
LOCK(g_Lock);
#endif
m_pTsReaderArg->TsLock.Enter();
std::list<cProxyServer *>::iterator it = m_pTsReaderArg->TsReceiversList.begin();
while (it != m_pTsReaderArg->TsReceiversList.end())
{
if (*it == this)
{
m_pTsReaderArg->TsReceiversList.erase(it);
break;
}
++it;
}
m_pTsReaderArg->TsLock.Leave();
// このインスタンスはチャンネル排他権を持っているか？
if (m_bChannelLock == 0xff)
{
// 持っていた場合は、排他権取得待ちのインスタンスは存在しているか？
if (m_pTsReaderArg->WaitExclusivePrivList.size() > 0)
{
// 存在する場合は、リスト先頭のインスタンスに排他権を引き継ぎ、リストから削除
cProxyServer *p = m_pTsReaderArg->WaitExclusivePrivList.front();
m_pTsReaderArg->WaitExclusivePrivList.pop_front();
p->m_bChannelLock = 0xff;
}
}
else
{
// 持っていない場合は、排他権取得待ちリストに自身が含まれているかもしれないので削除
m_pTsReaderArg->WaitExclusivePrivList.remove(this);
}
// 可能性は低いがゼロではない…
if (m_pTsReaderArg->TsReceiversList.empty())
{
m_pTsReaderArg->StopTsRead = TRUE;
::WaitForSingleObject(m_hTsRead, INFINITE);
::CloseHandle(m_hTsRead);
delete m_pTsReaderArg;
}
}
}
m_bChannelLock = 0;
m_hTsRead = NULL;
m_pTsReaderArg = NULL;
m_bTunerOpen = FALSE;
break;
}
case ePurgeTsStream:
{
if (m_hTsRead)
{
m_pTsReaderArg->TsLock.Enter();
if (m_pTsReaderArg->TsReceiversList.size() <= 1)
{
PurgeTsStream();
m_pTsReaderArg->pos = 0;
}
m_pTsReaderArg->TsLock.Leave();
makePacket(ePurgeTsStream, TRUE);
}
else
makePacket(ePurgeTsStream, FALSE);
break;
}
case eRelease:
m_Error.Set();
break;
case eEnumTuningSpace:
{
if (pPh->GetBodyLength() != sizeof(DWORD))
makePacket(eEnumTuningSpace, _T(""));
else
{
LPCTSTR p = EnumTuningSpace(::ntohl(*(DWORD *)(pPh->m_pPacket->payload)));
if (p)
makePacket(eEnumTuningSpace, p);
else
makePacket(eEnumTuningSpace, _T(""));
}
break;
}
case eEnumChannelName:
{
if (pPh->GetBodyLength() != (sizeof(DWORD) * 2))
makePacket(eEnumChannelName, _T(""));
else
{
LPCTSTR p = EnumChannelName(::ntohl(*(DWORD *)(pPh->m_pPacket->payload)), ::ntohl(*(DWORD *)&(pPh->m_pPacket->payload[sizeof(DWORD)])));
if (p)
makePacket(eEnumChannelName, p);
else
makePacket(eEnumChannelName, _T(""));
}
break;
}
case eSetChannel2:
{
if (pPh->GetBodyLength() != ((sizeof(DWORD) * 2) + sizeof(BYTE)))
makePacket(eSetChannel2, (DWORD)0xff);
else
{
m_bChannelLock = pPh->m_pPacket->payload[sizeof(DWORD) * 2];
BOOL bLocked = FALSE;
cProxyServer *pHavePriv = NULL;
{
#ifndef STRICT_LOCK
LOCK(g_Lock);
#endif
for (std::list<cProxyServer *>::iterator it = g_InstanceList.begin(); it != g_InstanceList.end(); ++it)
{
if (*it == this)
continue;
if ((m_pIBon != NULL) && (m_pIBon == (*it)->m_pIBon))
{
if ((*it)->m_bChannelLock > m_bChannelLock)
bLocked = TRUE;
else if ((*it)->m_bChannelLock == 0xff)
{
// 対象チューナに対して優先度255のインスタンスが既にいる状態で、このインスタンスが
// 要求している優先度も255の場合、このインスタンスの優先度を暫定的に254にする
// (そうしないと、優先度255のインスタンスもチャンネル変更できなくなる為)
m_bChannelLock = 0xfe;
bLocked = TRUE;
pHavePriv = *it;
}
if ((m_hTsRead == NULL) && ((*it)->m_hTsRead != NULL))
{
m_hTsRead = (*it)->m_hTsRead;
m_pTsReaderArg = (*it)->m_pTsReaderArg;
m_pTsReaderArg->TsLock.Enter();
m_pTsReaderArg->TsReceiversList.push_back(this);
m_pTsReaderArg->TsLock.Leave();
}
}
}
// このインスタンスの優先度が下げられた場合
if (pHavePriv != NULL)
{
if (m_hTsRead)
{
// 排他権取得待ちリストにまだ自身が含まれていなければ追加
BOOL bFind = FALSE;
std::list<cProxyServer *>::iterator it = m_pTsReaderArg->WaitExclusivePrivList.begin();
while (it != m_pTsReaderArg->WaitExclusivePrivList.end())
{
if (*it == this)
{
bFind = TRUE;
break;
}
++it;
}
if (!bFind)
m_pTsReaderArg->WaitExclusivePrivList.push_back(this);
}
else
{
// このインスタンスの優先度が下げられたが、排他権を持っているインスタンスへの配信が
// 開始されていない場合は、そのインスタンスから排他権を奪う
// こうする事が挙動として望ましいのかどうかは微妙だが、そもそもここに来るのは、
// 当該インスタンスでのSetChannel()の失敗後、何もせずに接続だけ続けている状態であり、
// 可能性としてはゼロではないものの、かなりのレアケースに限られるはず
pHavePriv->m_bChannelLock = 0;
m_bChannelLock = 0xff;
}
}
}
if (bLocked)
makePacket(eSetChannel2, (DWORD)0x01);
else
{
if (m_hTsRead)
m_pTsReaderArg->TsLock.Enter();
BOOL b = SetChannel(::ntohl(*(DWORD *)(pPh->m_pPacket->payload)), ::ntohl(*(DWORD *)&(pPh->m_pPacket->payload[sizeof(DWORD)])));
if (m_hTsRead)
{
// 一旦ロックを外すとチャンネル変更前のデータが送信されない事を保証できなくなる為、
// チャンネル変更前のデータの破棄とCNRの更新指示はここで行う
if (b)
{
m_pTsReaderArg->pos = 0;
m_pTsReaderArg->ChannelChanged = TRUE;
}
m_pTsReaderArg->TsLock.Leave();
}
if (b)
{
makePacket(eSetChannel2, (DWORD)0x00);
if (m_hTsRead == NULL)
{
#ifndef STRICT_LOCK
// すぐ上で検索してるのになぜ再度検索するのかと言うと、同じBonDriverを要求している複数の
// クライアントから、ほぼ同時のタイミングで最初のeSetChannel2をリクエストされた場合の為
// eSetChannel2全体をまとめてロックすれば必要無くなるが、BonDriver_Proxyがロードされ、
// それが自分自身に接続してきた場合デッドロックする事になる
// なお、同様の理由でeCreateBonDriver, eOpenTuner, eCloseTunerのロックは実は不完全
// しかし、自分自身への再帰接続を行わないならば完全なロックも可能
// 実際の所、テスト用途以外で自分自身への再接続が必要になる状況と言うのはまず無いと
// 思うので、STRICT_LOCKが定義してある場合は完全なロックを行う事にする
// ただしそのかわりに、BonDriver_Proxyをロードし、そこからのプロキシチェーンのどこかで
// 自分自身に再帰接続した場合はデッドロックとなるので注意
BOOL bFind = FALSE;
LOCK(g_Lock);
for (std::list<cProxyServer *>::iterator it = g_InstanceList.begin(); it != g_InstanceList.end(); ++it)
{
if (*it == this)
continue;
if (m_pIBon == (*it)->m_pIBon)
{
if ((*it)->m_hTsRead != NULL)
{
bFind = TRUE;
m_hTsRead = (*it)->m_hTsRead;
m_pTsReaderArg = (*it)->m_pTsReaderArg;
m_pTsReaderArg->TsLock.Enter();
m_pTsReaderArg->TsReceiversList.push_back(this);
m_pTsReaderArg->TsLock.Leave();
break;
}
}
}
if (!bFind)
{
#endif
m_pTsReaderArg = new stTsReaderArg();
m_pTsReaderArg->TsReceiversList.push_back(this);
m_pTsReaderArg->pIBon = m_pIBon;
m_hTsRead = ::CreateThread(NULL, 0, cProxyServer::TsReader, m_pTsReaderArg, 0, NULL);
if (m_hTsRead == NULL)
{
delete m_pTsReaderArg;
m_pTsReaderArg = NULL;
m_Error.Set();
}
else
::SetThreadPriority(m_hTsRead, g_ThreadPriorityTsReader);
#ifndef STRICT_LOCK
}
#endif
}
}
else
makePacket(eSetChannel2, (DWORD)0xff);
}
}
break;
}
case eGetTotalDeviceNum:
makePacket(eGetTotalDeviceNum, GetTotalDeviceNum());
break;
case eGetActiveDeviceNum:
makePacket(eGetActiveDeviceNum, GetActiveDeviceNum());
break;
case eSetLnbPower:
{
if (pPh->GetBodyLength() != sizeof(BYTE))
makePacket(eSetLnbPower, FALSE);
else
makePacket(eSetLnbPower, SetLnbPower((BOOL)(pPh->m_pPacket->payload[0])));
break;
}
case eGetClientInfo:
{
union {
SOCKADDR_STORAGE ss;
SOCKADDR_IN si4;
SOCKADDR_IN6 si6;
};
char addr[INET6_ADDRSTRLEN], buf[512], info[1024], *p, *exinfo;
int port, len, num = 0;
size_t left, size;
p = info;
p[0] = '\0';
left = size = sizeof(info);
exinfo = NULL;
std::list<cProxyServer *>::iterator it = g_InstanceList.begin();
while (it != g_InstanceList.end())
{
len = sizeof(ss);
if (::getpeername((*it)->m_s, (SOCKADDR *)&ss, &len) == 0)
{
if (ss.ss_family == AF_INET)
{
// IPv4
#ifdef _WIN64
::inet_ntop(AF_INET, &(si4.sin_addr), addr, sizeof(addr));
#else
::lstrcpyA(addr, ::inet_ntoa(si4.sin_addr));
#endif
port = ::ntohs(si4.sin_port);
}
else
{
// IPv6
#ifdef _WIN64
::inet_ntop(AF_INET6, &(si6.sin6_addr), addr, sizeof(addr));
#else
char *cp = addr;
for (int i = 0; i < 16; i += 2)
cp += ::wsprintfA(cp, "%02x%02x%c", si6.sin6_addr.s6_addr[i], si6.sin6_addr.s6_addr[i + 1], (i != 14) ? ':' : '\0');
#endif
port = ::ntohs(si6.sin6_port);
}
}
else
{
::lstrcpyA(addr, "unknown host...");
port = 0;
}
len = ::wsprintfA(buf, "%02d: [%s]:[%d] / [%s]\n", num, addr, port, (*it)->m_strBonDriver);
if ((size_t)len >= left)
{
left += size;
size *= 2;
if (exinfo != NULL)
{
char *bp = exinfo;
exinfo = new char[size];
::lstrcpyA(exinfo, bp);
delete[] bp;
}
else
{
exinfo = new char[size];
::lstrcpyA(exinfo, info);
}
p = exinfo + ::lstrlenA(exinfo);
}
::lstrcpyA(p, buf);
p += len;
left -= len;
num++;
++it;
}
if (exinfo != NULL)
{
size = (p - exinfo) + 1;
p = exinfo;
}
else
{
size = (p - info) + 1;
p = info;
}
cPacketHolder *ph = new cPacketHolder(eGetClientInfo, size);
::memcpy(ph->m_pPacket->payload, p, size);
m_fifoSend.Push(ph);
if (exinfo != NULL)
delete[] exinfo;
break;
}
default:
break;
}
delete pPh;
break;
}
case WAIT_OBJECT_0 + 2:
// 終了要求
// fall-through
default:
// 何かのエラー
m_Error.Set();
goto end;
}
}
end:
::WaitForMultipleObjects(2, hThread, TRUE, INFINITE);
::CloseHandle(hThread[0]);
::CloseHandle(hThread[1]);
return 0;
}