/*
 * sum_latency --
 *	Sum latency for a set of threads.
 */
static void
sum_latency(WTPERF *wtperf, size_t field_offset, TRACK *total)
{
	WTPERF_THREAD *thread;
	TRACK *trk;
	int64_t i;
	u_int j;

	memset(total, 0, sizeof(*total));

	for (i = 0, thread = wtperf->workers;
	    thread != NULL && i < wtperf->workers_cnt; ++i, ++thread) {
		trk = (TRACK *)((uint8_t *)thread + field_offset);

		for (j = 0; j < ELEMENTS(trk->us); ++j) {
			total->ops += trk->us[j];
			total->us[j] += trk->us[j];
		}
		for (j = 0; j < ELEMENTS(trk->ms); ++j) {
			total->ops += trk->ms[j];
			total->ms[j] += trk->ms[j];
		}
		for (j = 0; j < ELEMENTS(trk->sec); ++j) {
			total->ops += trk->sec[j];
			total->sec[j] += trk->sec[j];
		}
	}
}

/**
 * find_charset_map:
 * @charset: An 8bit charset.
 *
 * Find charset -> UCS-2 map.
 *
 * Returns: Pointer to the map, #NULL when not found.
 **/
static const EncaUnicodeMap*
find_charset_map(int charset)
{
  static int charset_id[ELEMENTS(UNICODE_MAP)];
  static int charset_id_initialized = 0;
  size_t i;

  if (charset < 0)
    return NULL;

  if (!charset_id_initialized) {
    for (i = 0; i < ELEMENTS(UNICODE_MAP); i++) {
      charset_id[i] = enca_name_to_charset(UNICODE_MAP[i].name);
      assert(charset_id[i] != ENCA_CS_UNKNOWN);
    }
    charset_id_initialized = 1;
  }

  for (i = 0; i < ELEMENTS(UNICODE_MAP); i++) {
    if (charset_id[i] == charset)
      return UNICODE_MAP + i;
  }

  return NULL;
}

/*===========================================================================*
 *				pt_sanitycheck		     		     *
 *===========================================================================*/
PUBLIC void pt_sanitycheck(pt_t *pt, char *file, int line)
{
    /* Basic pt sanity check. */
    int i;
    int slot;

    MYASSERT(pt);
    MYASSERT(pt->pt_dir);
    MYASSERT(pt->pt_dir_phys);

    for(slot = 0; slot < ELEMENTS(vmproc); slot++) {
        if(pt == &vmproc[slot].vm_pt)
            break;
    }

    if(slot >= ELEMENTS(vmproc)) {
        vm_panic("pt_sanitycheck: passed pt not in any proc", NO_NUM);
    }

    MYASSERT(usedpages_add(pt->pt_dir_phys, I386_PAGE_SIZE) == OK);

    for(i = proc_pde; i < I386_VM_DIR_ENTRIES; i++) {
        if(pt->pt_pt[i]) {
            if(!(pt->pt_dir[i] & I386_VM_PRESENT)) {
                printf("slot %d: pt->pt_pt[%d] = 0x%lx, but pt_dir entry 0x%lx\n",
                       slot, i, pt->pt_pt[i], pt->pt_dir[i]);
            }
            MYASSERT(pt->pt_dir[i] & I386_VM_PRESENT);
            MYASSERT(usedpages_add(I386_VM_PFA(pt->pt_dir[i]),
                                   I386_PAGE_SIZE) == OK);
        } else {
            MYASSERT(!(pt->pt_dir[i] & I386_VM_PRESENT));
        }
    }
}

void CServerSession::RunSession( SOCKET sock )
{
    char buf[MAXCMDBUF];
    CNcpMessage* pMsg = (CNcpMessage*)buf;

    //initialize the state and socket.
    ASSERT( m_sock==0 );
    m_sock = sock;
    m_state = NCPS_CLOSED;

    while( true ) {
        pMsg->Recv( m_sock, ELEMENTS(buf) );

        if( m_state==NCPS_CLOSED ) {
            if( pMsg->GetCmd()!=CM_LOGON ) {
                pMsg->Init( CM_ACK );
                pMsg->SetRet( E_UNKNOWN );
                pMsg->Send( m_sock );
                continue;
            }
        }

        PumpMessage( pMsg, ELEMENTS(buf) );

        if( m_state==NCPS_CLOSED )break;
    }
}

uint8_t
smtp_tree_words_conds (struct pkt_desc * const pkt)
{
  /* conditions data */
  /* last element HAS to be empty == "\0", it is termination */
  static const char *const mc_words_smtp[] = { "SMTP", "smtp", "" };	/* no need for ESMTP */
  static const char *const mc_words_mail[] = { "mail", "MAIL", "Mail", "" };
  static const char *const mc_words_server[] =
    { "Postfix", "Sendmail", "postffix", "sendmail", "" };
  static const char *const mc_words_os[] =
    { "GNU", "Debian", "debian", "windows", "Windows", "" };
  static const char *const *const mc_words[] =
    { mc_words_smtp, mc_words_mail, mc_words_server, mc_words_os };

  uint8_t conds = 0;
  size_t i;

  for (i = 0; i < ELEMENTS (mc_words); ++i)
    {
      size_t j;

      for (j = 0; mc_words[i][j][0] != '\0'; ++j)
	{
	  if (memmem
	      (OFFSETED (pkt), REMAINING (pkt), mc_words[i][j],
	       strlen (mc_words[i][j])))
	    {
	      BIT_SET (conds, (ELEMENTS (mc_words) - 1) - i);
	      break;
	    }
	}
    }

  return conds;
}

int CClientSession::DoGetFile( const char* strSrc, const char* strDst )
{
    char buf[MAXPATH+sizeof(CNcpMessage)];
    CNcpMessage* pMsg = (CNcpMessage*)buf;

    //step 1. request passive mode to get the data channel address
    short dataport=0;

    int nRet = DoPassive( &dataport );
    if( FAILED(nRet) )return nRet;

    //step 2. send the put file command.
    pMsg->Init( CM_GETFILE );
    strcpy( pMsg->GetData(), strSrc );
    pMsg->SetDataSize( strlen(strSrc)+1 );
    pMsg->Send( m_sock );

    //wait for the return code and check it
    if( !pMsg->Recv( m_sock, ELEMENTS(buf) ) ) {
        return E_BROKEN;		//broken connection
    }

    ASSERT( pMsg->IsAck() );
    if( pMsg->IsFailed() ) {
        return pMsg->GetRet();
    }

    //step 3. now the server agrees on the file transfer, connect the data channel and send file
    SOCKADDR_IN addr;
    socklen_t nlen = sizeof(SOCKADDR_IN);
    GetPeerName( m_sock, (SOCKADDR*)&addr, &nlen );
    addr.sin_port = htons( dataport );

    SOCKET sockdata;
    //import, must retry the socket initilization a few times.
    int i;
    for( i=0; i<MAXRETRY; i++ ) {
        sockdata = Socket( PF_INET, SOCK_STREAM, 0 );
        ASSERT( sockdata!=INVALID_SOCKET );

        if( ::connect( sockdata, (SOCKADDR*)&addr, sizeof(SOCKADDR_IN) )==0 )break;
        closesocket( sockdata );
    }
    if( i>=MAXRETRY )throw new CSockException();

    int nLen = RecvFileEx( sockdata, strDst, m_nFileMode );
    closesocket( sockdata );

    //step 4. exchange the error code.
    pMsg->Init( CM_ACK, nLen );
    pMsg->Send( m_sock );

    //wait for the return code and check it
    if( !pMsg->Recv( m_sock, ELEMENTS(buf) ) ) {
        return E_BROKEN;		//broken connection
    }

    ASSERT( pMsg->IsAck() );
    return pMsg->GetRet();
}

/******************************************************************************
 * Securely delete the given file. This involves overwriting it with various
 * bits, truncating it, and then unlinking it. Return non-zero if there is
 * an error during this process.
 */
int secdel(const char* filename) {
  static unsigned char buf[256];
  static unsigned char bytes[]={0xaa,0x55};
  struct stat sb;
  unsigned char ch;
  unsigned long fsize; /* (size of file) / 256 */
  int f,i,j,rc;

  if ((f=open(filename,O_RDWR))<0) return errno;
  if (fstat(f,&sb)) return errno;
  fsize=sb.st_size/sizeof(buf)+1;
  for(i=0;i<=ELEMENTS(bytes);++i) {
    if (i<ELEMENTS(bytes))
      memset(buf,bytes[i],sizeof(buf));
    else {
      srand(time(NULL)); /* In case sranddev() fails. */
      /*sranddev(); not supported on Linux */
      for(j=0;j<ELEMENTS(buf);++j)
	buf[j]=(unsigned char)(rand()&0xff);
    }
    for(j=0;j<fsize;++j)
      write(f,(void*)buf,sizeof(buf));
  }
  close(f);

  /* Truncate this file to 0 bytes. */
  f=open(filename,O_RDWR|O_TRUNC);
  close(f);

  /* Remove this file from the filesystem. */
  rc=unlink(filename);
  return rc;
} /* int secdel(const char* filename) */

cSatipPluginSetup::cSatipPluginSetup()
: detachedModeM(SatipConfig.GetDetachedMode()),
  deviceCountM(0),
  operatingModeM(SatipConfig.GetOperatingMode()),
  ciExtensionM(SatipConfig.GetCIExtension()),
  eitScanM(SatipConfig.GetEITScan()),
  numDisabledSourcesM(SatipConfig.GetDisabledSourcesCount()),
  numDisabledFiltersM(SatipConfig.GetDisabledFiltersCount())
{
  debug1("%s", __PRETTY_FUNCTION__);
  operatingModeTextsM[cSatipConfig::eOperatingModeOff]    = tr("off");
  operatingModeTextsM[cSatipConfig::eOperatingModeLow]    = tr("low");
  operatingModeTextsM[cSatipConfig::eOperatingModeNormal] = tr("normal");
  operatingModeTextsM[cSatipConfig::eOperatingModeHigh]   = tr("high");
  for (unsigned int i = 0; i < ELEMENTS(cicamsM); ++i)
      cicamsM[i] = SatipConfig.GetCICAM(i);
  for (unsigned int i = 0; i < ELEMENTS(ca_systems_table); ++i)
      cicamTextsM[i] = ca_systems_table[i].description;
  if (numDisabledSourcesM > MAX_DISABLED_SOURCES_COUNT)
     numDisabledSourcesM = MAX_DISABLED_SOURCES_COUNT;
  for (int i = 0; i < MAX_DISABLED_SOURCES_COUNT; ++i)
      disabledSourcesM[i] = SatipConfig.GetDisabledSources(i);
  if (numDisabledFiltersM > SECTION_FILTER_TABLE_SIZE)
     numDisabledFiltersM = SECTION_FILTER_TABLE_SIZE;
  for (int i = 0; i < SECTION_FILTER_TABLE_SIZE; ++i) {
      disabledFilterIndexesM[i] = SatipConfig.GetDisabledFilters(i);
      disabledFilterNamesM[i] = tr(section_filter_table[i].description);
      }
  SetMenuCategory(mcSetupPlugins);
  Setup();
  SetHelp(trVDR("Button$Scan"), NULL, tr("Button$Devices"), trVDR("Button$Info"));
}

bool CServerSession::OnSoftLink( CNcpMessage* pMsg, int nBufSize )
{
    char path_src[MAXPATH], path_lnk[MAXPATH];

    //parse the parameters
    string strSrc = pMsg->GetData();
    string strLnk = pMsg->GetData()+strSrc.size()+1;

    if( IsAbsDir( strSrc.c_str() ) ) {
        strcpy( path_src, strSrc.c_str() );
    } else {
        strcpy( path_src, m_strCurDir.c_str() );
        CatDir( path_src, strSrc.c_str(), path_src, ELEMENTS(path_src) );
    }
    if( IsAbsDir( strLnk.c_str() ) ) {
        strcpy( path_lnk, strLnk.c_str() );
    } else {
        strcpy( path_lnk, m_strCurDir.c_str() );
        CatDir( path_lnk, strLnk.c_str(), path_lnk, ELEMENTS(path_lnk) );
    }

    int nRet = 0;
#ifdef _WIN32
    nRet = E_NOSUPT;
#else
    symlink( path_src, path_lnk );
    nRet = S_OK;
#endif

    //send back the return code.
    pMsg->Init( CM_ACK, nRet );
    pMsg->Send( m_sock );

    return SUCCEEDED(nRet);
}

void cSatipPluginSetup::Setup(void)
{
  int current = Current();

  Clear();
  helpM.Clear();

  Add(new cMenuEditStraItem(tr("Operating mode"), &operatingModeM, ELEMENTS(operatingModeTextsM), operatingModeTextsM));
  helpM.Append(tr("Define the used operating mode for all SAT>IP devices:\n\noff - devices are disabled\nlow - devices are working at the lowest priority\nnormal - devices are working within normal parameters\nhigh - devices are working at the highest priority"));

  if (operatingModeM) {
     Add(new cMenuEditBoolItem(tr("Enable CI extension"), &ciExtensionM));
     helpM.Append(tr("Define whether a CI extension shall be used.\n\nThis setting enables integrated CI/CAM handling found in some SAT>IP hardware (e.g. Digital Devices OctopusNet)."));

     for (unsigned int i = 0; ciExtensionM && i < ELEMENTS(cicamsM); ++i) {
         Add(new cMenuEditStraItem(*cString::sprintf(" %s #%d", tr("CI/CAM"), i + 1), &cicamsM[i], ELEMENTS(cicamTextsM), cicamTextsM));
         helpM.Append(tr("Define a desired CAM type for the CI slot.\n\nThe '---' option lets SAT>IP hardware do the auto-selection."));
         }

     Add(new cMenuEditBoolItem(tr("Enable EPG scanning"), &eitScanM));
     helpM.Append(tr("Define whether the EPG background scanning shall be used.\n\nThis setting disables the automatic EIT scanning functionality for all SAT>IP devices."));

     Add(new cMenuEditIntItem(tr("Disabled sources"), &numDisabledSourcesM, 0, MAX_DISABLED_SOURCES_COUNT, tr("none")));
     helpM.Append(tr("Define number of sources to be disabled.\n\nSAT>IP servers might not have all satellite positions available and such sources can be blacklisted here."));

     for (int i = 0; i < numDisabledSourcesM; ++i) {
         Add(new cSatipEditSrcItem(*cString::sprintf(" %s %d", trVDR("Source"), i + 1), &disabledSourcesM[i]));
         helpM.Append(tr("Define a source to be blacklisted."));
         }

     Add(new cMenuEditIntItem(tr("Disabled filters"), &numDisabledFiltersM, 0, SECTION_FILTER_TABLE_SIZE, tr("none")));
     helpM.Append(tr("Define number of section filters to be disabled.\n\nCertain section filters might cause some unwanted behaviour to VDR such as time being falsely synchronized. By blacklisting the filters here, useful section data can be left intact for VDR to process."));

     for (int i = 0; i < numDisabledFiltersM; ++i) {
         Add(new cMenuEditStraItem(*cString::sprintf(" %s %d", tr("Filter"), i + 1), &disabledFilterIndexesM[i], SECTION_FILTER_TABLE_SIZE, disabledFilterNamesM));
         helpM.Append(tr("Define an ill-behaving filter to be blacklisted."));
         }
     }
  Add(new cMenuEditStraItem(tr("Transport mode"), &transportModeM, ELEMENTS(transportModeTextsM), transportModeTextsM));
  helpM.Append(tr("Define which transport mode shall be used.\n\nUnicast, Multicast, RTP-over-TCP"));
  Add(new cOsdItem(tr("Active SAT>IP servers:"), osUnknown, false));
  helpM.Append("");

  detachedModeM = SatipConfig.GetDetachedMode();
  if (!detachedModeM) {
     cSatipServers *servers = cSatipDiscover::GetInstance()->GetServers();
     deviceCountM = servers->Count();
     for (cSatipServer *s = servers->First(); s; s = servers->Next(s)) {
         Add(new cSatipServerItem(s));
         helpM.Append("");
         }
     }

  SetCurrent(Get(current));
  Display();
}

static void TermState_Fail(TermState *state)
{
	assert(state->alt_stack_pos>0);
	--state->alt_stack_pos;
	assert(state->alt_stack_pos<(int)ELEMENTS(state->alt_stack));
	state->proc = state->alt_stack[state->alt_stack_pos];
	assert(state->alt_stack_pos<(int)ELEMENTS(state->bufpos_stack));
	state->bufpos = state->bufpos_stack[state->alt_stack_pos];
	assert(state->alt_stack_pos<(int)ELEMENTS(state->cont_stack_pos_stack));
	state->cont_stack_pos = state->cont_stack_pos_stack[state->alt_stack_pos];
}

static void TermState_PushAlternative(TermState *state,TermStateProc *proc)
{
	assert(state->alt_stack_pos<(int)ELEMENTS(state->bufpos_stack));
	state->bufpos_stack[state->alt_stack_pos] =
		TermState_PrevBufPos(state,state->bufpos);
	assert(state->alt_stack_pos<(int)ELEMENTS(state->alt_stack));
	state->alt_stack[state->alt_stack_pos] = proc;
	assert(state->alt_stack_pos<(int)ELEMENTS(state->cont_stack_pos_stack));
	state->cont_stack_pos_stack[state->alt_stack_pos] = state->cont_stack_pos;
	++state->alt_stack_pos;
}

GShell * new_ronny(GShell *ronny,int Setup)
{
   if (!ronny) ronny = new GShell;
   ronny->Make(ELEMENTS(ronny_points),(Point*) ronny_points,
		ELEMENTS(ronny_faces),ronny_faces);
   if (Setup) {
      ronny->ComputeFaceNormals();
      ronny->ComputeVertexNormals();
      ronny->ComputeBounds();
   }
   return (ronny);
}

void MCS_list_registry(MCExecPoint& p_context)
{
	char *t_full_key;
	t_full_key = p_context . getsvalue() . clone();

	p_context . clear();

	char *t_root_key;
	t_root_key = t_full_key;
	
	char *t_child_key;
	t_child_key = strchr(t_full_key, '\\');
	if (t_child_key != NULL)
		*t_child_key++ = '\0';
	else
		t_child_key = NULL;

	uint2 i;
	MCString s = t_root_key;
	for (i = 0 ; i < ELEMENTS(Regkeys) ; i++)
		if (s == Regkeys[i].token)
			break;

	HKEY t_key;
	if (i >= ELEMENTS(Regkeys) || RegOpenKeyExA(Regkeys[i] . key, t_child_key, 0, KEY_READ, &t_key) != ERROR_SUCCESS)
	{
		MCresult -> sets("bad key");
		delete t_full_key;
		return;
	}

	DWORD t_index;
	t_index = 0;
	for(;;)
	{
		LONG t_result;
		char t_name[256];
		DWORD t_name_length;
		t_name_length = 256;
		t_result = RegEnumKeyExA(t_key, t_index, t_name, &t_name_length, NULL, NULL, NULL, NULL);
		if (t_result == ERROR_NO_MORE_ITEMS)
			break;
		p_context . concatchars(t_name, t_name_length, EC_RETURN, t_index == 0);
		t_index += 1;
	}

	RegCloseKey(t_key);
	delete t_full_key;
}

bool CServerSession::OnLogOn( CNcpMessage* pMsg, int nBufSize )
{
    char path[MAXPATH];

    //parse parameters
    int nFileMode = pMsg->GetRet();
    string strUser = (char*)pMsg->GetData();
    string strPass = (char*)( pMsg->GetData()+strUser.size()+1 );

    //get home path
#ifdef _WIN32
    GetModuleFileName( NULL, path, ELEMENTS(path) );
    char* p = strrchr( path, '\\' );
    if( p!=NULL )*p = '\0';
#else
    getcwd( path, ELEMENTS(path) );
#endif
    CatDir( path, strUser.c_str(), path, ELEMENTS(path) );	//now path is the current home path.

    //make home directory if necessary
    int nRet = S_OK;
    if( !IsDirExist(path) ) {
        if( MkDir( path )!=0 ) {
            nRet = E_ACCES;
        }
    }
    m_strHomeDir = path;
    m_strCurDir = m_strHomeDir;
    m_nFileMode = nFileMode;

    if( SUCCEEDED(nRet) && !IsDirExist(m_strHomeDir.c_str()) ) {
        nRet = E_NOUSER;
    }
    pMsg->Init( CM_ACK, nRet );
    pMsg->Send( m_sock );

    //switch established
    if( SUCCEEDED(nRet) ) {
        m_state = NCPS_ESTABLISHED;
        if( strcmp( strUser.c_str(), "root" )==0 )m_bRootUsr = true;

        ASSERT( m_pServApp );
        //lock the same user logon from other hosts.
        m_pLocker = m_pServApp->GetSessionLocker( strUser.c_str() );
        m_pLocker->Lock();
    }
    return SUCCEEDED(nRet);
}

bool CHostSet::Add( IN_ADDR addrHost, bool bIsAlive )
{
	char buf[MAXLINE];
	//get local host address
	gethostname( buf, ELEMENTS(buf) );
	hostent* phent = gethostbyname( buf );
	IN_ADDR addrloc;
	bcopy( phent->h_addr, &addrloc, sizeof(IN_ADDR) );

	//force not using local host. avoid treat local host as a computation node
	if( !IsUseLocalHost() ){
		if( addrloc.S_un.S_addr==addrHost.S_un.S_addr )return false;
	}

//	CHostObject* pHostObj = new CHostObject( addrHost, this );
//	if( m_trHosts.Search( pHostObj )==NULL ){
	if( m_trHosts.SearchByKey( addrHost )==NULL ){
		CHostObject* pHostObj = new CHostObject( addrHost, this );
		m_trHosts.Insert( pHostObj );

		if( bIsAlive ){
			m_trAliveHosts.Insert( pHostObj );
			ReleaseSemaphore( m_smAlives );
		}else{
			m_trDeadHosts.Insert( pHostObj );
		}
		return true;
	}

//	delete pHostObj;
	return false;
}

static void TermState_Continue(TermState *state)
{
	assert(state->cont_stack_pos>0);
	--state->cont_stack_pos;
	assert(state->cont_stack_pos<(int)ELEMENTS(state->cont_stack));
	state->proc = state->cont_stack[state->cont_stack_pos];
}

/// <summary>Return the list of supported geometry types. For example, if a client wanted to know if a provider supported
/// multi-polygons, it would call GetGeometryTypes and check if the MultiPolygon type was listed.</summary>
/// <param name="length">Output the number of geometry types.</param> 
/// <returns>Returns the list of geometry types</returns> 
FdoGeometryType* SuperMapGeometryCapabilities::GetGeometryTypes (FdoInt32& length)
{
	TRACE(_T("调用 SuperMapGeometryCapabilities::GetGeometryTypes()... \n"));
    static const FdoGeometryType geomTypes[] =
    {
	
        FdoGeometryType_Point,
        FdoGeometryType_LineString,
        FdoGeometryType_Polygon,
        FdoGeometryType_MultiPoint,			
        FdoGeometryType_MultiLineString,	// 支持多点、多线
		FdoGeometryType_MultiPolygon,

		FdoGeometryType_MultiGeometry

		/*shp
		FdoGeometryType_Point,
        FdoGeometryType_LineString,
        FdoGeometryType_Polygon,
        FdoGeometryType_MultiPoint,
        FdoGeometryType_MultiLineString,
		*/
	};

    length = ELEMENTS(geomTypes);
    return ((FdoGeometryType *)geomTypes);
}

bool checkCASystem(unsigned int cicamP, int caidP)
{
  // always skip the first row
  if ((cicamP > 0) && (cicamP < ELEMENTS(ca_systems_table)))
     return ((caidP >= ca_systems_table[cicamP].start) && (caidP <= ca_systems_table[cicamP].end));
  return false;
}

////////////////////////////////////////////////////////////////////////////////
// funcload()
//
// This function is called to define all function names in the ADS
// function table.  Each named function will be callable from lisp or
// invokable from another ADS application.
//
static int
funcload()
{
    unsigned short i;
    AvErrorCode retval;
    static int sbInitialized = FALSE;

    // AVLIB: we must call av_loadlib() to assure that Render.arx
    // is loaded.
    //
    if (!sbInitialized) {
        retval = av_loadlib();
        if (retval != AvRetNorm) {
            acdbFail("Library initialization failed.\n");
            return RTERROR;
        }
        sbInitialized = TRUE;
    }
    
    // call acedDefun() for each function name 
    // in gFunctionTable

    for (i = 0; i < ELEMENTS(gFunctionTable); i++) {
        if (acedDefun(gFunctionTable[i].name, (short)i) != RTNORM)
            return RTERROR;
    }

    return RTNORM;
}