Mensajes

Gracias por tus sugerencias estoy corriendo el código disculpa de que biblioteca son AF_INET y ERROR_INSUFICIENT_BUFFER ya que me da un error de compilación que no están declarados esos identificadores



Salodos lo de "AF_INET" ya encontré en que biblioteca asociada a la dll se encontraba pero sigo sin poder encontrar donde está declarado "ERROR_INSUFICIENT_BUFFER"

Gracias Eternal Idol el código me resulto de mucha utilidad hice algunos cambios lo dejo aquí para que sirva de referencia a otros:

Código (cpp) [Seleccionar] Expandir


DWORD size= 64;

LPVOID table = new BYTE[size];


while( dwResult = GetExtendedTcpTable(table, &size, false, AF_INET, TCP_TABLE_OWNER_PID_ALL, 0)
== ERROR_INSUFICIENT_BUFFER)
delete [] table, table = new BYTE[size *= 2];

if(dwResut != NO_ERROR)
{
//TODO error
return NULL;
}


PMIB_TCPTABLE_OWNER_PID tabla = (PMIB_TCPTABLE_OWNER_PID)table;

disculpa las molestias pero ahora tengo la duda quiero obtener sólo un registro de toda la lista de estructura es decir hacer un for que me recorra toda la lista pero sólo recuperar dwOwningPid de la estructura MIB_TCPROW_OWNER_PID

Saludos estoy haciendo un proceso que me recupere los procesos que están usando una conexión TCP/IP leyendo la documentación MSDN esta función devuelve los datos que necesito pero tengo dudas con el primer parámetro de salida que es donde se recupera la tabla de la estructura con los datos, según la documentación MSDN la sintaxis de la función es la siguiente:

Código (cpp) [Seleccionar] Expandir

DWORD GetExtendedTcpTable(
 _Out_    PVOID pTcpTable,
 _Inout_  PDWORD pdwSize,
 _In_     BOOL bOrder,
 _In_     ULONG ulAf,
 _In_     TCP_TABLE_CLASS TableClass,
 _In_     ULONG Reserved
);

el problema que tengo es con el parámetro pTcpTable según entiendo debe ser una estructura de datos que ya existe en "tcpmib.h" pero no se como usar estas estructuras y como recuperaría los datos que envía la función en esta variable.

la función la he definido de la siguiente manera:

Código (cpp) [Seleccionar] Expandir

DWORD size;
DWORD dwResult;


dwResult = GetExtendedTcpTable( , size, false, AF_INET, TCP_TABLE_OWNER_PID_ALL, 0);

les agradecería me ayudaran en comprender mejor para usar esta función



Una aclaración la variable size no le he asignado ningún valor porque igual como no se que estructura es pTcpTable no puedo darle un valor.

Código (cpp) [Seleccionar] Expandir


size = sizeof (PVOID)
//no se que estructura corresponde pTcpTable el tipo lo pone como PVOID

Saludos quiero  probar si un vector me devuelve bien los datos antes de programar los datos que va recibir el constructor tengo un contructor en una biblioteca que he creado llamada NetXh.h y la forma del constructor es:
struct NetxInfo
{
public:
   ULONG pid;
   WCHAR filename[MAX_PATH];
   WCHAR pathname[MAX_PATH];

   WCHAR protocol[10];
   WCHAR state [MAX_PATH];
   WCHAR srcip[MAX_PATH];
   WCHAR destip[MAX_PATH];
};

ahora bien donde incluyo el archivo Netxh.h creo un vector:

vector<NetxInfo>* initialNetxes = new vector<NetxInfo>();

quiero agregarle valores (basura) sólo para probar si la función que me va devolver este vector funciona bien.

como puedo agregarle valores de forma estática



no se si lo puedo hacer de la forma:
initialNetxes[0].pid = <dato>;
initialNetxes[0].filename = <dato>;
.
.
.
initialNetex[0].destip = <dato>;
para todo el vector que contiene la estructura NetxInfo

Disculpa Eternal Idol como podría hacer para vicular cada proceso que me devuelve GetProcessList a su respectivo servicios

Hola Eternal Idol estaba viendo el link que pones utiliza la función GetProcessList pero tanbién me mostrará los procesos que son propios del sistema operativo como por ejemplo svchost.exe y como puedo saber los servicios asociados a cada proceso?

Hola, espero me puedan ayudar necesito hacer una mini aplicación en C++ que me muestre todos los procesos que están activos en windows y los servicios que usa cada proceso algo así como lo que hace el process explorer según he investigado la forma de poder lograrlo es por el WMI pero no he podido encontrar mucha información encontré un código en C++ donde hacen la conexión COM y verifican el nombre de la computadora no se si alguien me puede decir si este código me sirve y que líneas puedo agregar para que me consulte los procesos y los servicios asociados a cada proceso.


#define _WIN32_DCOM
#include <iostream>
using namespace std;
#include <comdef.h>
#include <Wbemidl.h>

# pragma comment(lib, "wbemuuid.lib")

int main(int argc, char **argv)
{
    HRESULT hres;

    // Step 1: --------------------------------------------------
    // Initialize COM. ------------------------------------------

    hres =  CoInitializeEx(0, COINIT_MULTITHREADED);
    if (FAILED(hres))
    {
        cout << "Failed to initialize COM library. Error code = 0x"
            << hex << hres << endl;
        return 1;                  // Program has failed.
    }

    // Step 2: --------------------------------------------------
    // Set general COM security levels --------------------------
    // Note: If you are using Windows 2000, you need to specify -
    // the default authentication credentials for a user by using
    // a SOLE_AUTHENTICATION_LIST structure in the pAuthList ----
    // parameter of CoInitializeSecurity ------------------------

    hres =  CoInitializeSecurity(
        NULL,
        -1,                          // COM authentication
        NULL,                        // Authentication services
        NULL,                        // Reserved
        RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication
        RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation 
        NULL,                        // Authentication info
        EOAC_NONE,                   // Additional capabilities
        NULL                         // Reserved
        );

                     
    if (FAILED(hres))
    {
        cout << "Failed to initialize security. Error code = 0x"
            << hex << hres << endl;
        CoUninitialize();
        return 1;                    // Program has failed.
    }
   
    // Step 3: ---------------------------------------------------
    // Obtain the initial locator to WMI -------------------------

    IWbemLocator *pLoc = NULL;

    hres = CoCreateInstance(
        CLSID_WbemLocator,             
        0,
        CLSCTX_INPROC_SERVER,
        IID_IWbemLocator, (LPVOID *) &pLoc);

    if (FAILED(hres))
    {
        cout << "Failed to create IWbemLocator object."
            << " Err code = 0x"
            << hex << hres << endl;
        CoUninitialize();
        return 1;                 // Program has failed.
    }

    // Step 4: -----------------------------------------------------
    // Connect to WMI through the IWbemLocator::ConnectServer method

    IWbemServices *pSvc = NULL;

    // Connect to the root\cimv2 namespace with
    // the current user and obtain pointer pSvc
    // to make IWbemServices calls.
    hres = pLoc->ConnectServer(
         _bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace
         NULL,                    // User name. NULL = current user
         NULL,                    // User password. NULL = current
         0,                       // Locale. NULL indicates current
         NULL,                    // Security flags.
         0,                       // Authority (for example, Kerberos)
         0,                       // Context object
         &pSvc                    // pointer to IWbemServices proxy
         );
   
    if (FAILED(hres))
    {
        cout << "Could not connect. Error code = 0x"
             << hex << hres << endl;
        pLoc->Release();     
        CoUninitialize();
        return 1;                // Program has failed.
    }

    cout << "Connected to ROOT\\CIMV2 WMI namespace" << endl;


    // Step 5: --------------------------------------------------
    // Set security levels on the proxy -------------------------

    hres = CoSetProxyBlanket(
       pSvc,                        // Indicates the proxy to set
       RPC_C_AUTHN_WINNT,           // RPC_C_AUTHN_xxx
       RPC_C_AUTHZ_NONE,            // RPC_C_AUTHZ_xxx
       NULL,                        // Server principal name
       RPC_C_AUTHN_LEVEL_CALL,      // RPC_C_AUTHN_LEVEL_xxx
       RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
       NULL,                        // client identity
       EOAC_NONE                    // proxy capabilities
    );

    if (FAILED(hres))
    {
        cout << "Could not set proxy blanket. Error code = 0x"
            << hex << hres << endl;
        pSvc->Release();
        pLoc->Release();     
        CoUninitialize();
        return 1;               // Program has failed.
    }

    // Step 6: --------------------------------------------------
    // Use the IWbemServices pointer to make requests of WMI ----

    // For example, get the name of the operating system
    IEnumWbemClassObject* pEnumerator = NULL;
    hres = pSvc->ExecQuery(
        bstr_t("WQL"),
        bstr_t("SELECT * FROM Win32_OperatingSystem"),
        WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
        NULL,
        &pEnumerator);
   
    if (FAILED(hres))
    {
        cout << "Query for operating system name failed."
            << " Error code = 0x"
            << hex << hres << endl;
        pSvc->Release();
        pLoc->Release();
        CoUninitialize();
        return 1;               // Program has failed.
    }

    // Step 7: -------------------------------------------------
    // Get the data from the query in step 6 -------------------

    IWbemClassObject *pclsObj;
    ULONG uReturn = 0;
   
    while (pEnumerator)
    {
        HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
            &pclsObj, &uReturn);

        if(0 == uReturn)
        {
            break;
        }

        VARIANT vtProp;

        // Get the value of the Name property
        hr = pclsObj->Get(L"Name", 0, &vtProp, 0, 0);
        wcout << " OS Name : " << vtProp.bstrVal << endl;
        VariantClear(&vtProp);

        pclsObj->Release();
    }

    // Cleanup
    // ========
   
    pSvc->Release();
    pLoc->Release();
    pEnumerator->Release();
    pclsObj->Release();
    CoUninitialize();

    return 0;   // Program successfully completed.

}