Mensajes

Hola amigos del foro.
He estado intentando implementar en C++ una TLS Callback. La cuestion es que no logro dar con mi objetivo. He estado buscando en la red algo de info y este es el codigo que encontre y que estoy usando:

Código (cpp) [Seleccionar] Expandir

#include <windows.h>
char mensaje[] = "Hola desde la TLS Callback";

void __stdcall tls_callback(void * /*instance*/,
                        DWORD reason,
                        void * /*reserved*/)
{
  if ( reason == DLL_PROCESS_ATTACH )
  {
    MessageBox(NULL, "Proceso Adherido", "TLS Callback", MB_OK);
    OutputDebugStringA(mensaje);
  }
}

DWORD _tls_index = 0;
PIMAGE_TLS_CALLBACK callback = tls_callback;
extern "C" IMAGE_TLS_DIRECTORY _tls_used = {0, 0, (DWORD)&_tls_index, (DWORD) &callback, 0, 0};

int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
    MessageBox(NULL,"Este es el WinMain!","Hola!",MB_OK);
    return 0;
}

El codigo compila sin problemas, pero al revisar el ejecutable creado, el mismo no contiene ninguna TLS Callback, por lo que no funciona. En la web donde encontre el codigo (no recuerdo bien donde) dicen que ese codigo les funcionaba, pero a mi no y no tengo idea de lo que pueda estar mal.
Si alguien sabe que puede estar mal o que falta, o de que otra forma se pudiera implementar una TLS Callback, le agradeceria algunos tips Por cierto, estoy usando el BCBuilder6.
Saludos

Código (cpp) [Seleccionar] Expandir


char _a='f';
char *_buffer=&_a;
int main()
{
 
asm("movl $3,%eax");
asm("movl $0,%ebx ");
asm("mov _buffer,%ecx"); //asm("mov _a,%ecx ");    <---- esta linea
asm("mov $30,%edx");
asm("int $0x50");       

    system("PAUSE");
    return EXIT_SUCCESS;
}


me dice [Linker Error] undefined reference to `buffer'  e probado colocando la variable "a" directamente pero medice en mismo problema con dicha variable

como lo arreglo  si me aclaran la duda

Me parece que tu problema esta con el uso de la sintaxis AT&T lee un poco sobre el asm inline con el compilador GCC, aqui te pongo un texto de referencia
http://www.ibiblio.org/gferg/ldp/GCC-Inline-Assembly-HOWTO.html

...
Yo se bstante sobre el  tema pero podrías hacerme un tutorial o poner links de algunos buenos.
Por favor que incluyan algo de bugs y exploits aunque ese ya tengo buenos tutos y yo se com hacer yo uno.
Por favor correnselo un poco. Comentar y contesto ...

Att N30h}

Bastante modesto no? 
Busca en esta web, alli encontraras mas de 1000 tutoriales

http://ricardonarvaja.info/WEB/CURSO%20NUEVO/TEORIAS%20NUMERADAS/

[Variante#2 - Metodo1================]

Bueno, ya que nadie aporta, me respondo yo mismo y de paso aporto tambien para alguien con el mismo problema que encuentre este post en la red. Por ahora lo he solucionado por la variante#2, aunque no estoy 100% conforme, pero bueno, es lo que hay, aun asi seguire investigando en la variante#1 y si logro algo lo posteo aqui tambien.

Variante#2 - Metodo1
================
Esta variante la he sacado de dos formas distintas. La primera es de un post parecido a este que encontre en el foro de VB el codigo lo pueden ver aqui: http://foro.elhacker.net/programacion_visual_basic/problemas_con_ejecutar_cualquier_archivo_y_esperar_a_que_termine-t205423.0.html
Asi que lo que hice fue pasarlo a CBuilder6 y aqui esta el codigo resultante:

Código (cpp) [Seleccionar] Expandir

//---------------------------------------------------------------------------
#include <vcl.h>
#include <psapi.h>
#pragma hdrstop
#pragma comment(lib,"C:\Archivos de programa\Borland\CBuilder6\Lib\Psdk\Psapi.lib")

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{
}
//---------------------------------------------------------------------------

bool TForm1::ShellWait(AnsiString sShell, int eFocus)
{
    HANDLE lhProcess = NULL;
    DWORD lRet = 0;
    DWORD lProc = 0;
    TList *cProcs = new TList();

    // Se ejecuta el archivo especificado
    if ((INT)ShellExecute(0, "open", sShell.c_str(), NULL, NULL, eFocus) > 32)
    {
        // Se enumeran todos los procesos y se devuelve
        // un listado de ellos
cProcs = (TList*)EnumProcs();
        // Se toma el ultimo proceso que se creo de la lista
lProc = (*(DWORD*)cProcs->Items[cProcs->Count - 1]);
    }

    // Se abre toma la informacion del proceso
    lhProcess = OpenProcess(PROCESS_QUERY_INFORMATION, false, lProc);

    if (lhProcess == 0)
        return false;

    do
    {  // Se iterara mientras el proceso se mantenga activo
       GetExitCodeProcess(lhProcess, &lRet);
       Application->ProcessMessages();
       Sleep(100);
    }while(lRet == STILL_ACTIVE);

    // Liberamos memoria
    CloseHandle(lhProcess);
    delete cProcs;
   
    return true;
}
//---------------------------------------------------------------------------

TList* TForm1::EnumProcs()
{
    DWORD lvProcesses[1024] = {0};
    DWORD lNedded = 0;
    TList *cTemp = new TList();

    // Enumeramos todos los procesos en ejecucion
    if (EnumProcesses(lvProcesses, sizeof(lvProcesses) * 4, &lNedded) != 0)
    {
        for(UINT i = 0; i < (lNedded / sizeof(DWORD)); i++)
        {
           // Almacenamos en una lista cada proceso
           // Nota: Se almacenan por orden de ejecucion
           if (lvProcesses[i] != 0)
              cTemp->Add(&lvProcesses[i]);
        }     
    }

    return cTemp;
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)
{
    if(ShellWait("C:\\test.doc", SW_SHOWNORMAL))
        Application->Terminate();
}
//---------------------------------------------------------------------------

Ahora, con respecto a este metodo, es de aclarar que no siempre es 100% efectivo, y me explico. Supongamos que vamos a probar el codigo que he puesto, el cual abre el archivo "test.doc", pero antes de hacerlo ya teniamos con anterioridad una instancia del "WORD.EXE" abierta, y luego de haber ejecutado una que otra aplicacion mas (Winrar, AdobeReader, etc), probamos nuestro codigo y...veremos que abre el "test.doc", pero aun al cerrarlo, nuestra aplicacion no se termina.
Esto es debido a que el codigo anterior se basa en hacer un listado de todos los procesos que se ejecutan en la PC, tomando como referencia el ultimo proceso creado, como el proceso de nuestro archivo, y por este sera por el que esperara a que termine. Ahora en el ejemplo que puse anteriormente, ya teniamos una instancia del "WORD.EXE" abierta, por lo que al lanzar el documento no se crea ningun nuevo proceso y se tomara como referencia el ultimo proceso de la lista, no siendo este el correcto.

Variante#2 - Metodo2
================
El segundo metodo que utilizo es el que comentaba en el primer post, y es haciendo uso de las API's ShellExecuteEx y WaitForSingleObject, aqui esta:

Código (cpp) [Seleccionar] Expandir

//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)
{
   SHELLEXECUTEINFO execInfo;
   char filename[MAX_PATH] = "C:\\test.doc";

   ZeroMemory(&execInfo, sizeof(SHELLEXECUTEINFO));

   // Llenamos la estructura
   execInfo.cbSize = sizeof(SHELLEXECUTEINFO);
   execInfo.fMask = SEE_MASK_FLAG_DDEWAIT + SEE_MASK_FLAG_NO_UI + SEE_MASK_NOCLOSEPROCESS;
   execInfo.lpVerb = "open";
   execInfo.lpFile = filename;
   execInfo.nShow = SW_SHOWNORMAL;

   // Lanzamos el archivo
   ShellExecuteEx(&execInfo);

   // Verificamos que no hayan errores
   if ((int)execInfo.hInstApp <= 32)
   {
      if ((int)execInfo.hInstApp == SE_ERR_NOASSOC)
         MessageBox(NULL,
                          "No existe una aplicación asociada \na la extensión del archivo",
                          "Error",
                          MB_ICONERROR);

      MessageBox(NULL,
                       "No se ha podido ejecutar el archivo",
                       "Error",
                       MB_ICONERROR);
   }

   // Esperamos a que termine el proceso
   WaitForSingleObject(execInfo.hProcess, INFINITE);
   Application->Terminate();
}
//---------------------------------------------------------------------------

Este metodo al igual que el primero, tiene sus "contras", algo bien parecido a lo que sucede con el primer codigo.

A pesar de estos inconvenientes que he expuesto para cada metodo, el que mejores resultados da de los dos es el primero, asi que gracias a cobein del foro de VB por ese codigo que posteo hace unos años.
Como dije al principio, seguire investigando en la primera variante que expuse, de seguro sale algo interesante.

[Variante#1========]

Un saludo a todos los amigos del foro y ti que lees este post.
Vamos a ver, tengo esta aplicacion cuyo objetivo es el de ejecutar un archivo externo (.txt, .pdf, etc) con ShellExecute, ahora, lo que quiero es que, una vez ejecutado y cerrado dicho archivo, se borre del HD sin mas. Lo que quiero es algo asi como un fichero temporal, suponiendo que sea un txt, pues que una vez mi aplicacion lo abra con el bloc de notas y luego el usuario lo cierre, que este se elimine. La cuestion esta en que, como muchos pensaran, podria programar un DeleteFile justo antes de salir de mi aplicacion y listo, pero lo que quiero hacer es lo siguiente:

Variante#1
========
1- Ejecuto mi aplicacion
2- Mi aplicacion ejecuta el archivo (txt, pdf, doc, etc)
3- Mi aplicacion se cierra
4- Se continua abriendo el archivo con su programa predeterminado
5- Se termina de trabajar con el archivo abierto y se cierra
6- El archivo se elimina automaticamente

Ahora, otra variante que pudiera hacer seria moviendo el punto 3:

Variante#2
========
1- Ejecuto mi aplicacion
2- Mi aplicacion ejecuta el archivo (txt, pdf, doc, etc)
3- Se continua abriendo el archivo con su programa predeterminado
4- Se termina de trabajar con el archivo abierto y se cierra
5- Mi aplicacion sabe que se cerro el archivo y lo elimina
6- Mi aplicacion se cierra

Ahora, la cosa se complica al no ser un .exe el que se ejecuta, sino cualquier tipo de archivo que depende de una segunda aplicacion para abrirse, por lo que no puedo hacer nada con WaitForSingleObject o cualquier API para el trabajo con procesos y su monitoreo (corriganme si estoy equivocado).

Variante#1
========
Para esto que quiero he estado investigando un poco las API's CreateFile y ShellExecuteEx. En cuanto a la primera, he visto un parametro muy interesante, me refiero a:

Código (cpp) [Seleccionar] Expandir

DWORD dwFlagsAndAttributes

especificamente en la bandera:

FILE_FLAG_DELETE_ON_CLOSE: The system deletes a file immediately after all of its handles are closed, which includes the specified handle and any other open or duplicated handles. If there are existing open handles to a file, the call fails unless they were all opened with the FILE_SHARE_DELETE share mode. Subsequent open requests for the file fail, unless the FILE_SHARE_DELETE share mode is specified.

Y yo tengo esto:

Código (cpp) [Seleccionar] Expandir

SECURITY_ATTRIBUTES secAttr;
ZeroMemory(&secAttr, sizeof(SECURITY_ATTRIBUTES));
secAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
secAttr.bInheritHandle = true; // Para que sea el mismo handle para todos los procesos

HANDLE hFile = CreateFile(filename,
                          GENERIC_ALL, // GENERIC_READ
                          FILE_SHARE_DELETE + FILE_SHARE_READ,
                          &secAttr, // 0
                          OPEN_EXISTING,
                          FILE_FLAG_DELETE_ON_CLOSE, // FILE_ATTRIBUTE_NORMAL
                          NULL);

Como ven eso es justo lo que necesito, pero aqui viene el otro problema, y es que una vez tomado el handle del archivo con estos valores, no tengo acceso permitido a el por una segunda aplicacion al no ser para eliminarlo, por lo que las llamadas con ShellExecute sobre el mismo daran error de acceso al intentar abrirlo.

Variante#2
========
Para la segunda variante, he investigado sobre la API ShellExecuteEx, exactamente hay un valor interesante en la estructura de parametro SHELLEXECUTEINFO, me refiero al valor:

Código (cpp) [Seleccionar] Expandir

HANDLE hProcess;

Handle to the newly started application. This member is set on return and is always NULL unless fMask is set to SEE_MASK_NOCLOSEPROCESS. Even if fMask is set to SEE_MASK_NOCLOSEPROCESS, hProcess will be NULL if no process was launched. For example, if a document to be launched is a URL and an instance of Microsoft Internet Explorer is already running, it will display the document. No new process is launched, and hProcess will be NULL.
Note ShellExecuteEx does not always return an hProcess, even if a process is launched as the result of the call. For example, an hProcess does not return when you use SEE_MASK_INVOKEIDLIST to invoke IContextMenu.

Y yo tengo esto:

Código (cpp) [Seleccionar] Expandir

SHELLEXECUTEINFO execInfo;

ZeroMemory(&execInfo, sizeof(SHELLEXECUTEINFO));
execInfo.cbSize = sizeof(SHELLEXECUTEINFO);
execInfo.fMask = SEE_MASK_FLAG_DDEWAIT + SEE_MASK_FLAG_NO_UI + SEE_MASK_NOCLOSEPROCESS;
execInfo.lpVerb = "open";
execInfo.lpFile = filename;
execInfo.nShow = SW_SHOWNORMAL;

ShellExecuteEx(&execInfo);

Pero por lo que dicen de el, vemos que no seria confiable para esto, ademas que lo he intentado con el si exito alguno.

Perdon por este post tan largo, y gracias por el simple hecho de haber llegado hasta aqui (si es que llegaste...jeje), pero aqui es donde estoy detenido, y es que no se de que forma lograr lo que quiero,...si es con alguna combinacion exacta de valores en los parametros de CreateFile o en ShellExecuteEx que me permitan alguna de las dos variantes que expuse al principio.
Bueno, no doy mas lata...ya esta...alguien tiene alguna idea o me puede guiar a lo que quiero???
Saludos y gracias de antemano

Claro de ahi viene mi pregunta, lo intente hacer todo desde excel, esa es la idea... pero no ha resultado, o una cosa o la otra...
Y la opcion de proteger celdas sin que se pueda borrar nada seria la optima, de hecho la es, pero tengo que repetir ese paso pestaña por pestaña y son como 40.
Gracias por responder.

Realmente no entiendo cual es la complicacion que tienes, pues es algo bien sencillo. Igual te dejo un enlace, si sigues teniendo problemas, usa el google con las palabras: proteger+celdas+excel

http://www.aulaclic.es/excel2000/t_6a_1.htm

Lo haz intentado con el mismo Excel??
En el menu "Herramientas", opcion "Proteger"

Para administrar usuarios deberias investigar un poco sobre las funciones:
NetUserAdd, NetUserDel, NetUserEnum, NetUserGetInfo, NetUserSetInfo.
Saludos

Define en tu proyecto lo siguiente:

Código (cpp) [Seleccionar] Expandir

#define WIN_32_LEAN_AND_MEAN

Gracias Black, vere que hago con esta info 
Saludos