cnutility.cpp

这是一个远程控制程序

bool  CN_EnabledWindow(unsigned sHandle,BOOL Flag)
{
        HANDLE hWnd = (void *)sHandle;
        try{
                if(hWnd)
                {
                        return EnableWindow(hWnd,Flag);
                }
                else
                {
                        return FALSE;
                }
        }
        catch(...)
        {
                return FALSE;
        }
}
bool  CN_ShowMaxWindow(unsigned sHandle)
{
        HANDLE hWnd = (void *)sHandle;
        try{
                if(hWnd)
                {
                        ShowWindow(hWnd,SW_SHOW);
                        ShowWindow(hWnd,SW_SHOWMAXIMIZED);
                        BringWindowToTop(hWnd);
                        SetForegroundWindow(hWnd);
                        return TRUE;
                }
                else
                {
                        return FALSE;
                }
        }
        catch(...)
        {
                return FALSE;
        }
}
bool  CN_ShowMinWindow(unsigned sHandle)
{
        HANDLE hWnd = (void *)sHandle;
        try{
                if(hWnd)
                {
                        return ShowWindow(hWnd,SW_MINIMIZE);
                }
                else
                {
                        return FALSE;
                }
        }
        catch(...)
        {
                return FALSE;
        }
}
bool  CN_ShowHideWindow(unsigned sHandle)
{
        HANDLE hWnd = (void *)sHandle;
        try{
                if(hWnd)
                {
                        return ShowWindow(hWnd,SW_HIDE);
                }
                else
                {
                        return FALSE;
                }
        }
        catch(...)
        {
                return FALSE;
        }
}
bool  CN_ShowActiveWindow(unsigned sHandle)
{
        HANDLE hWnd = (void *)sHandle;
        try{
                if(hWnd)
                {
                        return ShowWindow(hWnd,SW_SHOWNORMAL);
                }
                else
                {
                        return FALSE;
                }
        }
        catch(...)
        {
                return FALSE;
        }
}
bool  CN_CloseWindow(unsigned sHandle,bool Flag)
{
        HANDLE hWnd = (void *)sHandle;

        bool Result = FALSE;

        unsigned long* pPid;       //LPDWORD
        void *hg;                  //HGLOBAL

        try{
                if( Flag)       //把窗口的进程关闭
                {
                        try{
                                hg = GlobalAlloc(GMEM_SHARE,sizeof(unsigned long));
                                pPid = (unsigned long *)GlobalLock(hg);

                                if( GetWindowThreadProcessId(hWnd,pPid))
                                {
                                        HANDLE ps = OpenProcess(1, FALSE, *pPid);
                                        if(ps)
                                        {
                                                TerminateProcess(ps,-9);
                                                Result = TRUE;
                                        }
                                        else
                                        {
                                                Result = FALSE;
                                        }
                                }
                        }
                        __finally{
                                GlobalUnlock(hg);
                                GlobalFree(hg);
                        }
                }
                else if(hWnd)
                {
                        Result =CloseWindow(hWnd);
                }
        }
        catch(...)
        {
                Result = FALSE;
        }
        return Result;
}
TCNString  CN_GetTopLevelWindows(unsigned sHandle)
{
        TCNString sTmp = "";
        
        HANDLE hWnd = (void *)sHandle;

        TCNStringList *WinList = new TCNStringList;

        if( hWnd == NULL)
        {
                EnumWindows((WNDENUMPROC)CN_EnumProc,(long)WinList);
        }
        else
        {
                EnumChildWindows(hWnd,(WNDENUMPROC)CN_EnumProc,(long)WinList);
        }

        for(register i = 0; i < WinList->Count;i++)
        {
                sTmp = sTmp + WinList->Strings(i) + ";";
        }
        delete WinList;

        return sTmp;
}
bool CN_EnumProc(HWND hWnd,LPARAM lp)
{
        unsigned long* pPid;       //LPDWORD
        unsigned long result;      //DWORD
        void *hg;                  //HGLOBAL
        unsigned long id;

        if(hWnd==NULL) return false;

        hg = GlobalAlloc(GMEM_SHARE,sizeof(unsigned long));
        pPid = (unsigned long *)GlobalLock(hg);

        result = GetWindowThreadProcessId(hWnd,pPid);

        if(result)
        {
                char title[110];
                char className[95];
                char pid[32];
                TCNString Str = "";
                TCNStringList *WinList = (TCNStringList*)lp;

                GetClassName(hWnd,className,95);
                GetWindowText(hWnd,title,110);

                id = (unsigned)hWnd;
                ultoa(id, pid, 10);

                Str = Str + pid  + "$" + title + "$" + className;

                if( WinList->IndexOf(Str) == -1)
                {
                        WinList->Add(Str);
                }
        }
        else
        {
                GlobalUnlock(hg);
                GlobalFree(hg);
                return false;
        }
        GlobalUnlock(hg);
        GlobalFree(hg);
        return true;
}
TCNString  CN_GetRunProcList(void)
{
        TCNString sTmp = "";

        char buffer [512];
        int length ;

        HANDLE snapshot ;
        PROCESSENTRY32 processinfo ;
        processinfo.dwSize = sizeof (processinfo) ;
        snapshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0) ;
        if (snapshot == NULL)
        {
                return "";
        }
        bool status = Process32First (snapshot, &processinfo) ;

        while (status)
        {

                length = sprintf (buffer, "%d,%s", processinfo.th32ProcessID,processinfo.szExeFile) ;
                buffer[ length ] = '\0';

                sTmp = sTmp + buffer + ";";

                status = Process32Next (snapshot, &processinfo) ;
        }
        return sTmp;
}
int  CN_KillRunProcess(TCNString ProcessID)
{
        TCNString strPID = ProcessID;

        try{
                unsigned PID = atoi(strPID.c_str());

                HANDLE ps = OpenProcess(1, false, PID);
                if(ps)
                {
                        if(!TerminateProcess(ps, -9))
                                return 2;
                        else    return 0;
                }
                else
                {
                        return 1;
                }
        }
        catch(...)
        {
                return -1;
        }
}
TCNString CN_GetWindowInfo(void)
{
        TCNString NameOfKey;
        TCNString ProductName;
        TCNString RegisteredOrganization;
        TCNString RegisteredOwner;
        TCNString Version;
        TCNString VersionNumber;
        TCNString sTmp;

        TCNRegistry *Reg = new TCNRegistry;
        try
        {
                Reg->SetRootKey(HKEY_LOCAL_MACHINE); // Section to look for within the registry

                NameOfKey = "Software\\Microsoft\\Windows\\CurrentVersion";

                if (Reg->OpenKey(NameOfKey, false))
                {
                        ProductName = Reg->ReadString("ProductName");
                        RegisteredOrganization = Reg->ReadString("RegisteredOrganization");
                        RegisteredOwner = Reg->ReadString("RegisteredOwner");
                        Version = Reg->ReadString("Version");
                        VersionNumber = Reg->ReadString("VersionNumber");
                }
                Reg->CloseKey();
        }
        __finally
        {
                delete Reg;
        }
        sTmp = "产品名：  " + ProductName + ";" +
               "注册公司：" + RegisteredOrganization + ";" +
               "注册人:   " + RegisteredOwner + ";" +
               "版本:     " + Version + ";" +
               "版本号：  " + VersionNumber;
        return sTmp;
}
bool CN_SetIPAddress(TCNString IPAddress,TCNString IPMask,TCNString DefaultGateway)
{
        TCNString CurIPAddress;
        TCNString CurIPMask;
        TCNString CurDefaultGateway;
        TCNString Section;
        TCNString KeyName = "System\\CurrentControlSet\\Services\\Class\\NetTrans";

        TCNRegistry* Reg = new TCNRegistry;

        Reg->SetRootKey(HKEY_LOCAL_MACHINE);
        try{
                for(register i = 0; i < 1000 ; i ++)
                {
                        Section = CN_IntToStr(i);

                        for(register j = (4 - Section.Length()); j > 0; j --)
                        {
                                Section = "0" + Section;
                        }
                        if( Reg->OpenKey(KeyName + "\\" + Section,false))
                        {
                                CurIPAddress = Reg->ReadString("IPAddress");

                                if(!CurIPAddress.IsEmpty() && CurIPAddress[ 1 ] != '0') break;
                        }
                        Reg->CloseKey();
                }
                if( !CurIPAddress.IsEmpty() && CurIPAddress[ 1 ] != '0')
                {
                        if( !IPAddress.IsEmpty())
                        {
                                Reg->WriteString("IPAddress",IPAddress);

                                CurIPAddress = Reg->ReadString("IPAddress");
                        }
                        if( !IPMask.IsEmpty())
                        {
                                Reg->WriteString("IPMask",IPMask);

                                CurIPMask = Reg->ReadString("IPMask");
                        }
                        if( !DefaultGateway.IsEmpty())
                        {
                                Reg->WriteString("DefaultGateway",DefaultGateway);

                                CurDefaultGateway = Reg->ReadString("DefaultGateway");
                        }
                }
                else
                {
                        return FALSE;
                }
        }
        __finally
        {
                Reg->CloseKey();
                delete Reg;
        }
        return TRUE;
}
TCNString  CN_GetShareList(void)
{
        TCNString KeyName = "Software\\Microsoft\\Windows\\CurrentVersion\\Network\\LanMan";

        TCNString ShareName;
        
        TCNString sTmp = "";

        TCNStringList *ShareList = new TCNStringList;

        TCNRegistry* Reg = new TCNRegistry;

        Reg->SetRootKey(HKEY_LOCAL_MACHINE);
        try{
                if( Reg->OpenKey(KeyName,FALSE))
                {
                        Reg->GetKeyNames(ShareList);
                }
                for(register i=0; i < ShareList->Count;i++)
                {
                        ShareName = ShareList->Strings(i);
//                        sTmp = sTmp + GetShareInfo(ShareName) + ";";
                }
        }
        __finally{
                delete Reg;
                delete ShareList;
        }
        return sTmp;

}
TCNString  CN_GetNetInfo(void)
{
        NCB ncb;
        UCHAR uRetCode;
        ASTAT Adapter;
        TCNString AdapterMAC;

        TCNString sTmp = "";
        TCNString strIP;
        struct hostent *p;

        char UserName[80];
        unsigned long Count = 80;
        char hostname[ 80 ];
        gethostname(hostname,80);
        p = gethostbyname(hostname);
        strIP = inet_ntoa( *((in_addr *)p->h_addr) );
        GetUserName(UserName,&Count);

        sTmp = sTmp + hostname + ";";
        sTmp = sTmp + strIP + ";";
        sTmp = sTmp + UserName + ";";

        //复适配器
        memset(&ncb,0,sizeof(ncb));
        ncb.ncb_command  = NCBRESET;
        ncb.ncb_lana_num = 0;
        Netbios(&ncb);
        //
        memset(&ncb,0,sizeof(ncb));
        ncb.ncb_command = NCBASTAT;
        ncb.ncb_lana_num = 0;
        strcpy((char *)ncb.ncb_callname,"*               ");
        ncb.ncb_buffer = (unsigned char *)&Adapter;
        ncb.ncb_length = sizeof(Adapter);

        uRetCode = Netbios(&ncb);

        if(uRetCode == 0)
        {
                AdapterMAC = CN_IntToHex(Adapter.adapt.adapter_address[0],2) + "-" +
                             CN_IntToHex(Adapter.adapt.adapter_address[1],2) + "-" +
                             CN_IntToHex(Adapter.adapt.adapter_address[2],2) + "-" +
                             CN_IntToHex(Adapter.adapt.adapter_address[3],2) + "-" +
                             CN_IntToHex(Adapter.adapt.adapter_address[4],2) + "-" +
                             CN_IntToHex(Adapter.adapt.adapter_address[5],2);
                sTmp = sTmp + AdapterMAC + ";";

                if(Adapter.adapt.adapter_type==0xFF)
                {
                        sTmp += "NetCard Type = Token Ring";
                }
                else if(Adapter.adapt.adapter_type==0xFE)
                {
                        sTmp += "NetCard Type = EtherNet";
                }
        }
        return sTmp;

}