void removeKeysFromLuksVolume( const char * device )
{
process_t p ;
__print( "remove a key from a luks volume using a key: " ) ;
p = Process( zuluCryptExe ) ;
ProcessSetArgumentList( p,"-r","-d",device,"-p",key,ENDLIST ) ;
ProcessStart( p ) ;
__ProcessGetResult( p ) ;
__print( "remove a key from a luks volume using a keyfile: " ) ;
p = Process( zuluCryptExe ) ;
ProcessSetArgumentList( p,"-r","-d",device,"-f",keyfile,ENDLIST ) ;
ProcessStart( p ) ;
__ProcessGetResult( p ) ;
}
static int mount_FUSEfs_0( m_struct * mst )
{
int status ;
const char * opts ;
process_t p = Process( ZULUCRYPTmount ) ;
string_t st = set_mount_options( mst ) ;
opts = _mount_options( mst->m_flags,st ) ;
if( StringsAreEqual( mst->fs,"ntfs" ) ){
if( StringHasComponent( opts,"ignore_case" ) ){
ProcessSetArgumentList( p,"-n","-t","lowntfs-3g","-o",opts,mst->device,mst->m_point,ENDLIST ) ;
}else{
ProcessSetArgumentList( p,"-n","-t","ntfs-3g","-o",opts,mst->device,mst->m_point,ENDLIST ) ;
}
}else{
ProcessSetArgumentList( p,"-t",mst->fs,"-o",opts,mst->device,mst->m_point,ENDLIST ) ;
}
ProcessStart( p ) ;
status = ProcessExitStatus( p ) ;
ProcessDelete( &p ) ;
StringDelete( &st ) ;
return status ;
}
int ProcessExecute( const char * exe,... )
{
char * entry ;
char ** args ;
char ** e ;
size_t size = sizeof( char * ) ;
int index = 1 ;
va_list list ;
process_t p ;
if( exe == NULL ){
return -1 ;
}
p = _process( exe ) ;
if( p == ProcessVoid ){
return -1 ;
}
args = p->args ;
va_start( list,exe ) ;
while( 1 ){
entry = va_arg( list,char * ) ;
e = realloc( args,( 1 + index ) * size ) ;
if( e == NULL ){
ProcessCleanUp( &p ) ;
free( args ) ;
va_end( list ) ;
_ProcessError() ;
return -1 ;
}else{
args = e ;
}
if( entry == NULL ){
*( args + index ) = NULL ;
break ;
}else{
*( args + index ) = entry ;
index++ ;
}
}
va_end( list ) ;
p->args = args ;
p->args[ 0 ] = p->exe ;
p->str.args = args ;
ProcessStart( p ) ;
return ProcessWaitUntilFinished( &p ) ;
}
void restoreHeaderBackup( const char * device,const char * msg )
{
process_t p ;
__print( msg ) ;
p = Process( zuluCryptExe ) ;
ProcessSetArgumentList( p,"-R","-k","-d",device,"-f",headerBackUp,ENDLIST ) ;
ProcessStart( p ) ;
__ProcessGetResult( p ) ;
}
void checkKeySlotsInUse( const char * device )
{
process_t p ;
__print( "check key slots in use: " ) ;
p = Process( zuluCryptExe ) ;
ProcessSetArgumentList( p,"-b","-d",device,ENDLIST ) ;
ProcessStart( p ) ;
__ProcessGetResultANDPrint( p ) ;
}
void closeVolume( const char * device,const char * msg )
{
process_t p ;
__print( msg ) ;
p = Process( zuluCryptExe ) ;
ProcessSetArgumentList( p,"-q","-d",device,ENDLIST ) ;
ProcessStart( p ) ;
__ProcessGetResult( p ) ;
}
void openVolumeWithPlugIn( const char * device,const char * msg )
{
process_t p ;
__print( msg ) ;
p = Process( zuluCryptExe ) ;
ProcessSetArgumentList( p,"-o","-d",device,"-m",mount_point,"-G",pluginPath,ENDLIST ) ;
ProcessStart( p ) ;
__ProcessGetResult( p ) ;
}
int zuluCryptCreateFileSystemInAVolume( const char * fs,const char * device_mapper )
{
int status ;
char * e = NULL ;
process_t p = Process( ZULUCRYPTmkfs ) ;
if( StringAtLeastOneMatch_1( fs,"ext2","ext3","ext4",NULL ) ){
ProcessSetArgumentList( p,"-t",fs,"-m","1",device_mapper,ENDLIST ) ;
}else if( StringsAreEqual( fs,"reiserfs" ) ){
ProcessSetArgumentList( p,"-t",fs,"-f","-f","-q",device_mapper,ENDLIST ) ;
}else if( StringsAreEqual( fs,"jfs" ) ){
ProcessSetArgumentList( p,"-t",fs,"-q",device_mapper,ENDLIST ) ;
}else if( StringsAreEqual( fs,"ntfs" ) ){
ProcessSetArgumentList( p,"-t",fs,"-f",device_mapper,ENDLIST ) ;
}else if( StringsAreEqual( fs,"xfs" ) ){
ProcessSetArgumentList( p,"-t",fs,"-f",device_mapper,ENDLIST ) ;
}else{
ProcessSetArgumentList( p,"-t",fs,device_mapper,ENDLIST ) ;
/*
* unhandled fs are processed here.They are given 60 seconds to accomplish their task
* and are assumed to be running in interactive more and are blocked waiting for user input
* when they fail to return in time and hence are killed since we cant get to them from GUI
*/
ProcessSetOptionTimeout( p,60,SIGKILL ) ;
}
ProcessStart( p ) ;
status = ProcessExitStatus( p ) ;
if( status ){
ProcessGetOutPut( p,&e,STDERROR ) ;
if( e ){
puts( e ) ;
free( e ) ;
}
}
ProcessDelete( &p ) ;
return status ;
}
static int create_group( const char * groupname )
{
process_t p ;
int r ;
zuluCryptSecurityGainElevatedPrivileges() ;
p = Process( ZULUCRYPTgroupadd,"-f",groupname,NULL ) ;
ProcessStart( p ) ;
r = ProcessWaitUntilFinished( &p ) ;
zuluCryptSecurityDropElevatedPrivileges();
return r == 0 ;
}
void createVolume( const char * device,const char * msg,const char * keysource,const char * type )
{
process_t p ;
__print( msg ) ;
p = Process( zuluCryptExe ) ;
if( strcmp( keysource,"-p" ) == 0 ){
ProcessSetArgumentList( p,"-c","-k","-d",device,"-t",type,keysource,key,ENDLIST ) ;
}else{
ProcessSetArgumentList( p,"-c","-k","-d",device,"-t",type,keysource,keyfile,ENDLIST ) ;
}
ProcessStart( p ) ;
__ProcessGetResult( p ) ;
}
void openVolume( const char * device,const char * msg,const char * keysource )
{
process_t p ;
__print( msg ) ;
p = Process( zuluCryptExe ) ;
if( strcmp( keysource,"-p" ) == 0 ){
ProcessSetArgumentList( p,"-o","-d",device,"-m",mount_point,keysource,key,ENDLIST ) ;
}else{
ProcessSetArgumentList( p,"-o","-d",device,"-m",mount_point,keysource,keyfile,ENDLIST ) ;
}
ProcessStart( p ) ;
__ProcessGetResult( p ) ;
}
void checkIfDeviceIsLuks( const char * device )
{
int st ;
process_t p = Process( zuluCryptExe ) ;
ProcessSetArgumentList( p,"-i","-d",device,ENDLIST ) ;
ProcessStart( p ) ;
st = ProcessExitStatus( p ) ;
ProcessDelete( &p ) ;
if( st ){
__print( "check if a luks volume is a luks volume: PASSED\n" ) ;
}
}
void addKeysToLuks( const char * device )
{
process_t p ;
__print( "add a key to a luks volume using a key and a key: " ) ;
p = Process( zuluCryptExe ) ;
ProcessSetArgumentList( p,"-a","-d",device,"-y",key,"-l",key1,ENDLIST ) ;
ProcessStart( p ) ;
__ProcessGetResult( p ) ;
__print( "add key to luks volume using keyfile and keyfile: " ) ;
p = Process( zuluCryptExe ) ;
ProcessSetArgumentList( p,"-a","-d",device,"-u",keyfile,"-n",keyfile1,ENDLIST ) ;
ProcessStart( p ) ;
__ProcessGetResult( p ) ;
__print( "add key to luks volume using passphrase and keyfile: " ) ;
p = Process( zuluCryptExe ) ;
ProcessSetArgumentList( p,"-a","-d",device,"-y",key,"-n",keyfile,ENDLIST ) ;
ProcessStart( p ) ;
__ProcessGetResult( p ) ;
__print( "add key to luks volume using keyfile and passphrase: " ) ;
p = Process( zuluCryptExe ) ;
ProcessSetArgumentList( p,"-a","-d",device,"-u",keyfile1,"-l",key1,ENDLIST ) ;
ProcessStart( p ) ;
__ProcessGetResult( p ) ;
}
int _loop_device_module_is_not_present( void )
{
struct stat stlsmod ;
int st = 0 ;
process_t p ;
const char * lsmod = "/sbin/lsmod" ;
char * output = NULL ;
if( stat( lsmod,&stlsmod ) != 0 ){
return 0 ;
}
p = Process( lsmod ) ;
ProcessStart( p ) ;
ProcessGetOutPut( p,&output,STDOUT ) ;
if( output ){
if( strstr( output,"\nloop" ) == NULL ){
st = 1 ;
}
free( output ) ;
}
ProcessDelete( &p ) ;
return st ;
}
int
tkNetMain(int pa_argn,char **in_args)
{
struct KeyInfoCache KeyInfoCache;
struct ProcessingList ProcList;
struct BackGroundArgs BkgdArgs;
struct PeerData PeerDataRoot;
struct Iterator ISeedPeer;
struct Sock MainSock;
struct BridgeProc BdgServerProc;
struct BridgeProc BdgClientProc;
char BdgPeerAddrStr[32];
char *pTargetName = NULL;
BOOL ifClientSkipRegister = 1;
int TestPurposeNatType;
struct BridgeClientProcPa *pBCPPa = NULL;
printf("tknet \n build: " TKNET_VER "\n");
tkNetInit();
MutexInit(&g_BkgdMutex);
ISeedPeer = GetIterator(NULL);
PeerDataCons(&PeerDataRoot);
PeerDataRoot.tpnd.RanPriority = 0;
PeerDataRoot.addr.port = 0;
PeerDataRoot.addr.IPv4 = 0;
ProcessingListCons( &ProcList );
RelayModuleInit();
KeyInfoCacheCons(&KeyInfoCache);
if(!KeyInfoReadFile(&KeyInfoCache,"tknet.info"))
{
printf("config file lost.\n");
goto exit;
}
if(!KeyInfoTry(&KeyInfoCache,KEY_INFO_TYPE_CONFIG,&MainSock))
{
printf("bad config format.\n");
goto exit;
}
if( g_TargetName[0] != '\0' )
{
printf("target name: %s \n", g_TargetName);
tkNetConnect(NULL);
}
else
{
printf("target name unset. \n");
}
if(g_ifConfigAsFullCone)
{
g_NATtype = NAT_T_FULL_CONE;
printf("config NAT type as fullcone.\n");
}
else
{
while(!KeyInfoTry(&KeyInfoCache,KEY_INFO_TYPE_STUNSERVER,&MainSock))
{
if(!KeyInfoTry(&KeyInfoCache,KEY_INFO_TYPE_MAILSERVER,&MainSock))
{
printf("No way to get NAT type.\n");
goto exit;
}
}
printf("NAT type got from STUN: %d\n",g_NATtype);
}
if(pa_argn == 2)
{
sscanf(in_args[1],"%d",&TestPurposeNatType);
g_NATtype = (uchar)TestPurposeNatType;
}
printf("final NAT type: %d\n",g_NATtype);
while(!KeyInfoTry(&KeyInfoCache,KEY_INFO_TYPE_BRIDGEPEER,&MainSock))
{
if(!KeyInfoTry(&KeyInfoCache,KEY_INFO_TYPE_MAILSERVER,&MainSock))
{
printf("no avalible Bridge peer.\n");
goto no_bdg_peer;
}
}
GetAddrText(&g_BdgPeerAddr,BdgPeerAddrStr);
printf("using Bridge peer: %s\n",BdgPeerAddrStr);
ifClientSkipRegister = 0;
no_bdg_peer:
pBCPPa = BridgeMakeClientProc(&BdgClientProc,&MainSock,&ProcList,&g_BdgPeerAddr,
g_MyName,g_NATtype,pTargetName,ifClientSkipRegister);
ProcessStart(&BdgClientProc.proc,&ProcList);
if(g_ifBkgdEnable)
printf("back ground enabled.\n");
else
printf("back ground disabled.\n");
BkgdArgs.pPeerDataRoot = &PeerDataRoot;
BkgdArgs.pInfoCache = &KeyInfoCache;
BkgdArgs.pProcList = &ProcList;
BkgdArgs.pBdgClientProc = &BdgClientProc;
BkgdArgs.pMainSock = &MainSock;
tkBeginThread( &BackGround , &BkgdArgs );
ConsAndStartBridgeServer(&BdgServerProc,&PeerDataRoot,&ProcList,&MainSock,&ISeedPeer);
while( g_MainLoopFlag )
{
MutexLock(&g_BkgdMutex);
if(!ifBkgdStunProc())
SockRead(&MainSock);
DoProcessing( &ProcList );
if(!ifBkgdStunProc())
MainSock.RecvLen = 0;
MutexUnlock(&g_BkgdMutex);
if(sta_ifBeginNewConnection && pBCPPa)
{
pBCPPa->pTargetNameID = g_TargetName;
sta_ifBeginNewConnection = 0;
}
tkMsSleep(100);
}
SockClose(&MainSock);
FreeBdgClientProc(&BdgClientProc);
FreeBridgeServer(&BdgServerProc);
exit:
PeerDataDestroy(&PeerDataRoot,&ISeedPeer);
KeyInfoUpdate( &KeyInfoCache );
KeyInfoWriteFile(&KeyInfoCache,"tknet.updateinfo");
KeyInfoFree(&KeyInfoCache);
RelayMuduleDestruction();
MutexDelete(&g_BkgdMutex);
tkNetUninit();
return 0;
}
void cActiveSkillObject::Init( sSKILL_CREATE_INFO* pInfo )
{
cSkillObject::Init(
pInfo);
GetTarget().RemoveAll();
// 광역 스킬은 시전자가 포함될지 여부를 클라이언트에서 조회해온다
if(TARGET_KIND_SINGLE == GetInfo().Area )
{
GetTarget().AddData(
pInfo->mainTarget.dwMainTargetID);
}
m_BuffSkillTable.RemoveAll();
for(DWORD i = 0; i < MAX_BUFF_COUNT; ++i)
{
const cBuffSkillInfo* const buffSkillInfo = SKILLMGR->GetBuffInfo(
GetInfo().Buff[i]);
if(0 == buffSkillInfo)
{
break;
}
else if(buffSkillInfo->GetInfo().IsEndTime &&
buffSkillInfo->GetInfo().NoUpdate)
{
CharacterBuffAdd(
GetOperator()->GetID(),
buffSkillInfo->GetIndex(),
buffSkillInfo->GetInfo().DelayTime,
buffSkillInfo->GetInfo().Count,
TRUE);
}
}
mAttackSpeedRate = 1.0f;
if( GetOperator()->GetObjectKind() == eObjectKind_Player )
{
CPlayer* pPlayer = ( CPlayer* )GetOperator();
if( GetInfo().Kind == SKILLKIND_PHYSIC ||
GetInfo().Kind == SKILLKIND_MAGIC )
{
if( (GetSkillIdx() / 100000) % 10 )
{
switch( GetInfo().Unit )
{
case UNITKIND_PHYSIC_ATTCK:
case UNITKIND_PHYSIC_FAKE_DAMAGE:
{
mAttackSpeedRate += ( ( pPlayer->GetRateBuffStatus()->PhysicSkillSpeedRate + pPlayer->GetRatePassiveStatus()->PhysicSkillSpeedRate ) * 0.01f );
}
break;
case UNITKIND_NONE:
case UNITKIND_MAGIC_ATTCK:
case UNITKIND_LIFE_RECOVER:
case UNITKIND_RESURRECTION:
case UNITKIND_DEBUFF:
case UNITKIND_MANA_RECOVER:
case UNITKIND_MAGIC_FAKE_DAMAGE:
{
float SpeedRate = min( pPlayer->GetRateBuffStatus()->MagicSkillSpeedRate + pPlayer->GetRatePassiveStatus()->MagicSkillSpeedRate, 99.f );
mAttackSpeedRate = ( 1 / ( 1 - ( SpeedRate*0.01f ) ) );
if( (GetInfo().CastingTime / mAttackSpeedRate) < MIN_MAGIC_CASTING_TIME )
mAttackSpeedRate = GetInfo().CastingTime / MIN_MAGIC_CASTING_TIME;
}
break;
}
}
else
{
mAttackSpeedRate += ( ( pPlayer->GetRateBuffStatus()->NormalSpeedRate + pPlayer->GetRatePassiveStatus()->NormalSpeedRate ) * 0.01f );
}
}
}
/// 플레이어의 경우
if( GetOperator()->GetObjectKind() == eObjectKind_Player )
{
mCoolingTick = gCurTime + GetInfo().CoolTime;
}
if( mAttackSpeedRate <= 0 )
{
mAttackSpeedRate = 1.0f;
}
MSG_SKILLOBJECT_ADD2 msg;
msg.Category = MP_SKILL;
msg.Protocol = MP_SKILL_SKILLOBJECT_ADD;
msg.bCreate = TRUE;
msg.SkillObjectInfo.SkillObjectIdx = pInfo->skillObjectId;
msg.SkillObjectInfo.SkillIdx = GetSkillIdx();
msg.SkillObjectInfo.Pos = pInfo->pos;
msg.SkillObjectInfo.StartTime = 0;
msg.SkillObjectInfo.Direction = pInfo->skillDir;
msg.SkillObjectInfo.SkillLevel = ( BYTE )pInfo->level;
msg.SkillObjectInfo.Operator = pInfo->operatorId;
msg.SkillObjectInfo.Rate = mAttackSpeedRate;
msg.SkillObjectInfo.RemainTime = 0;
msg.SkillObjectInfo.Count = 0;
memcpy( &( msg.SkillObjectInfo.MainTarget ), &( pInfo->mainTarget ), sizeof( MAINTARGET ) );
msg.SkillObjectInfo.BattleID = GetBattleID();
PACKEDDATA_OBJ->QuickSend( GetOperator(), &msg, sizeof( MSG_SKILLOBJECT_ADD2 ) );
GetOperator()->CurCastingSkillID = GetID();
if(0 < GetInfo().CastingTime)
{
CastingStart();
}
else
{
ProcessStart();
}
}
/*******************************************************************************
MAIN FUNCTION
*******************************************************************************/
int main(int ac, char **av)
{
FILE *fp;
int fd;
int pid;
int i, j, ln, err, kf, dRet;
int init_only_one = 0;
int verbose_flag = 0;
char buf[BUF_SIZE];
char fname[BUF_SIZE];
char block_name[BUF_SIZE];
char tmpbuf[128], errbuf[2048];
signal(SIGHUP, SIG_IGN);
signal(SIGCHLD, SIG_IGN);
signal(SIGQUIT, init_isr);
dRet = dGetUserPermission();
if( dRet == 0 )
{
sprintf(errbuf, "INAVLID USER PERMISSION\n" );
PrintOut(TIFB_FAIL, errbuf);
return 1;
}
dRet = dGetBlocks(FILE_MC_INIT,STR_TSW_COM);
if( dRet < 0 ){
sprintf(errbuf, "FAILED IN McInit\n" );
PrintOut(TIFB_FAIL, errbuf);
return 1;
}
else{
dCurrBlockCnt = dRet;
}
if( init_proc() < 0 ){
exit(0);
}
if (ac == 1) /*** ALL START ********************************************/
{
strcpy(fname, FILE_MC_INIT); /*** "McInit" File ****************************/
}
else if (ac > 3)
{
UsageExit();
}
else
{
for(i = 1;i < ac;i++)
{
if (av[i][0] != '-')
{
UsageExit();
}
else if(av[i][1] == 'b')
{
if( ac < 3 )
{
UsageExit();
}
else /*** ONLY ONE BLOCK START *****************************/
{
++i;
init_only_one = 1;
for(j = 0;j < strlen(av[i]);j++)
block_name[j] = toupper(av[i][j]);
block_name[j] = 0;
}
}
else if( av[i][1] == 'v' ) /*** ALL START ************************/
{
verbose_flag = 1;
}
else if(av[i][1] == 'd') {
/* FOR SYSTEM AUTO RESTART : WAIT BOOTTING COMPLETE */
sleep(300);
verbose_flag = 1;
}
else
{
UsageExit();
}
}
}
//freopen("/dev/null", "w", stdout);
/*** 한개 블럭을 기동 시킴 ************************************************/
if (init_only_one)
{
pid = InitOnlyOneBlock(block_name);
if(pid > 0)
{
sprintf(errbuf, "NEW BLOCK : %s\n PROCESS ID: %d\n", block_name, pid);
PrintOut(TIFB_SUCCESS, errbuf);
for(i=0; i< dCurrBlockCnt; i++)
{
if( STR_TSW_COM[i] == NULL )
continue;
if( !strcasecmp(block_name, STR_TSW_COM[i]) )
{
send_pid_msg(i, pid);
break;
}
}
}
exit(0);
}
/***************************************************************************
READ FIDB_FILE, SET SHARED MEMORY VALUE
***************************************************************************/
if ((fd = open (FILE_FIDB, O_RDONLY, 0666)) < 0)
{
}
else
{
remove( FILE_FIDB );
}
strcpy(fname, FILE_MC_INIT);
if((fp = fopen(fname, "r")) == NULL)
{
sprintf(errbuf, "CAN'T OPEN FILE %s\n", fname);
PrintOut(TIFB_FAIL, errbuf);
exit(1);
}
ln = cntr = 0;
/***************************************************************************
READ McInit File. SET blocks(bname, fname) VALUE
***************************************************************************/
while(fgets(buf, BUF_SIZE, fp) != NULL)
{
ln++;
if (AnalyzeLine(buf) < 0)
{
fclose(fp);
close(fd);
sprintf(errbuf, "SYNTAX ERROR (FILE: %s, LINE: %d)\n", fname, ln);
PrintOut(TIFB_FAIL, errbuf);
exit(1);
}
}
fclose(fp);
/***************************************************************************
WHEN ALL BLOCK IS STARTED, CHECK 2 TIMES
***************************************************************************/
if( verbose_flag == 0 )
{
fprintf(stderr, "\n\tBlocks to initialize are follows.\n");
PrintBlocks();
fprintf(stderr, "\tDo you want initialize (y/n) ? ");
err = GetYorN();
if(err == _NO)
{
sprintf(errbuf, "STOPPED BY USER REQUEST\n");
PrintOut(TIFB_SUCCESS, errbuf);
exit(0);
}
fprintf(stderr, "\n\tDo you really want initialize (y/n) ? ");
err = GetYorN();
if(err == _NO)
{
sprintf(errbuf, "STOPPED BY USER REQUEST\n");
PrintOut(TIFB_SUCCESS, errbuf);
exit(0);
}
}
sprintf(errbuf, "MAIN COMPUTER PROCESSS INITIALIZATION STARTED\n");
PrintOut( TIFB_SUCCESS , errbuf );
signal(SIGINT, init_isr);
/*** 프로세스 기동을 개시함 ***********************************************/
for(i=0; i<cntr; i++)
{
/*** 파일의 존재 및 수행가능성 조사 ***********************************/
if( IsCorrectBlock(i) < 0 )
{
if( verbose_flag == 1 )
{
continue;
}
else
{
sprintf(errbuf, "FILE %s DOES NOT EXIST\n", blocks[i].fname);
PrintOut(TIFB_FAIL, errbuf);
fprintf(stderr, "\n\tDo you want to continue (y/n) ? ");
err = GetYorN();
if(err == _YES)
{
inits[i].isinit = _FALSE;
continue;
}
else
{
final_isr();
}
}
}
/*** 이미 실행중인지 여부를 검사 **************************************/
if ( (pid = GetProcessID(blocks[i].bname)) > 0 )
{
/* 이미 실행중인 경우 */
if( verbose_flag == 1 )
{
err = _YES ;
}
else
{
fprintf(stderr, "\n\tBlock \"%s\" is already running.\n", blocks[i].bname);
fprintf(stderr, "\tDo you want replace block \"%s\" (y/n) ? ", blocks[i].bname);
err = GetYorN();
}
if(err == _NO)
{
inits[i].isinit = _FALSE;
continue;
}
else
{
/* New Version of Killing */
kf = kill(pid, SIGTERM);
if (kf < 0)
{
//sleep(2);
if (kill(pid, SIGTERM) < 0)
{
if (errno == ESRCH)
kf = 0;
}
else
{
kf = 0;
}
}
if ( kf && kill(pid, SIGKILL) < 0)
{
if( verbose_flag == 1 )
{
err = _YES ;
}
else
{
fprintf(stderr, "\tCan't kill process \"%d\"(%s)\n", pid, blocks[i].bname);
fprintf(stderr, "\tDo you want to continue (y/n) ? ");
err = GetYorN();
}
if(err == _YES)
{
inits[i].isinit = _FALSE;
continue;
}
else
{
final_isr();
}
}
else
{
sprintf(errbuf, "PROCESS %s(PID=%d) KILLED\n", blocks[i].fname, pid);
PrintOut(TIFB_SUCCESS, errbuf);
}
}
}
signal(SIGTERM, init_isr);
/***********************************************************************
PROCESS START
***********************************************************************/
err = ProcessStart(i);
if(err == -1)
{
if( verbose_flag == 1 )
{
continue;
}
else
{
sprintf(errbuf, "CAN'T START PROCESS BLOCK: %s\n", blocks[i].bname);
PrintOut(TIFB_FAIL, errbuf);
fprintf(stderr, "\tDo you want to continue (y/n) ? ");
}
}
else if(err == -2)
{
if( verbose_flag == 1 )
{
continue;
}
else
{
sprintf(errbuf, "PROGRAM NAME %s DOES NOT MEET NAME CONVENTION\n", blocks[i].fname);
strcat(errbuf, " ABANDON EXECUTING PROCESS\n");
PrintOut(TIFB_FAIL, errbuf);
fprintf(stderr, "\tDo you want to continue (y/n) ? ");
}
}
if(err < 0)
{
if( verbose_flag == 1 )
{
err = _YES;
}
else
{
err = GetYorN();
}
if(err == _NO)
{
final_isr();
}
else
{
inits[i].isinit = _FALSE;
continue;
}
}
else
{
sprintf(errbuf, "A PROCESS INIAILIZATION SUCCESS\n");
sprintf(tmpbuf, " BLOCK NAME : %s\n", blocks[i].bname);
strcat(errbuf, tmpbuf);
sprintf(tmpbuf, " PROGRAM NAME : %s\n", blocks[i].fname);
strcat(errbuf, tmpbuf);
sprintf(tmpbuf, " PROCESS ID : %d\n", err);
strcat(errbuf, tmpbuf);
PrintOut(TIFB_SUCCESS, errbuf);
sleep(1);
for(j=0; j< dCurrBlockCnt; j++)
{
if( STR_TSW_COM[i] == NULL )
continue;
if( !strcasecmp(blocks[i].bname, STR_TSW_COM[j]) )
{
send_pid_msg(j, err );
break;
}
}
inits[i].isinit = _TRUE;
inits[i].pid = err;
}
}
PrintSuccessBlocks();
printf("UPRESTO co. GTAM\n\n");
exit(1);
}
