Appeler fonction d'un exe a partir des paramètre entrer par l'utilisateur

Télécharger le projet
Commenter

Description

Vous pouvez maintenant appeler une fonction d'une dll en "ligne de commande".
Permets donc à l'utilisateur de pouvoir appeler, avec les paramètres qu'il aura choisis, d'appeler le pointeur d'une dll.

2 exemples sont dans la source.
Note: vous devez quand même respecter le nombre de paramètres du pointeur

Dll(...) : appelés le pointeur, les paramètres sont directement dans Dll().
Ex: dll("dll.dll","CallFuncExe","Ceci est le premier paramètre","2e paramètre","et on peut en mettre autant qu'on veut");

le 2e exemple se rapproche de la "ligne de commande".
Il utilise une seule variable char * le découpe en X paramètres avec Dll2();
char paramètre_dans_char[]="Ceci est le premier paramètre,2e paramètre,et on peut en mettre autant qu'on veut";
Dll2("dll.dll","CallFuncExe",paramètre_dans_char);

Pour le nom du fichier et le nom de la fonction il n'est pas très difficile de le demander a l'utilisateur donc je n'est pas plus compliqué la source.

Source / Exemple : 


#include <stdio.h>
#include <windows.h>

typedef void(*DLL_CALLEXE)(...);

// Équivalent de strtok mais qui retourne un tableau
// Retourne le nombre de token (ATTENTION, le nombre 0 compte pour un, donc si il retourne 1 il y a 2 tableau)
int motparmot(char *** output,char * input,int chart){
	int mots=0;
	int lettre=0;
	output[0]=(char**)malloc(1);
	output[0][0]=NULL;
	for(int i=0;i<=(int)strlen(input);i++){
		output[0][mots]=(char*)realloc(output[0][mots],lettre+1);
		if(i==strlen(input)) {
			output[0][mots][lettre]='\0';
			return mots;
		}else if(input[i]==chart){
			output[0][mots][lettre]='\0';
			// Note: le lettre++ plus bas va le remetre à 0
			lettre=-1;
			mots++;
			output[0][mots]=NULL;
		}else output[0][mots][lettre]=input[i];
	lettre++;
	}
	return -1;
}

// Fonction qui charge le pointeur
DLL_CALLEXE dll_loadfunc(char * filename,char * fonctionname){
	HMODULE DLL = LoadLibrary(filename);
	// L'erreur la plus courante retourné est "fichier non trouvé"
	if(!DLL) return (DLL_CALLEXE)-1;
	else {
		DLL_CALLEXE FonctionDll;
		// Charge l'adresse de la fonction CallFuncExe dans le DLL (pointeur)
		FonctionDll = (DLL_CALLEXE)GetProcAddress(DLL,fonctionname);
		if(!FonctionDll){ FreeLibrary(DLL); return (DLL_CALLEXE)-2; }
		return FonctionDll;
	}

}

// Fonctoin qui apelle le pointeur (merci à edcba du réseau EpikNet)
int calldll(int nbparam,void ** params,void * TmpFonction){
	int retvalue;
	_asm { 
		 mov ecx,nbparam 
		 mov ebx,params 
		 dec ecx 
		 js appel 
	 boucle: 
		 push [ebx+ecx*4] 
		 dec ecx 
		 jns boucle 
	appel: 
		  call TmpFonction 
		  mov retvalue,eax 
	 } 
	return retvalue;
}

void dll(int num,char * filename,char * fonctionname,...){
	// Charge le pointeur
	DLL_CALLEXE TmpFonction=NULL;
		TmpFonction=dll_loadfunc(filename,fonctionname);
		if((int)TmpFonction<1)  { MessageBox(0,"Impossible de charger la DLL","Erreur",0); exit((int)TmpFonction); }

	// parti où on récupère les paramètres non fixe (les ... a la fin de la fonction)
	// Un exemple : printf(), vous pouvez mettre autant de paramètre que voulu
	va_list marker;
	va_start(marker,num);
	va_arg(marker,char*);
	va_arg(marker,char*);

	// Prépare la liste des paramètres a envoyer au pointeur
	void** params; 
	params=(void**)malloc(num*sizeof(void*));
	for(int i=0; i < num;i++){
		params[i]=va_arg(marker,void*);
	}

	va_end(marker);
	// Appelle la fonction
	calldll(num,params,TmpFonction);

}

void dll2(char * filename,char * fonctionname,char * params,int chars){
	// Charge le pointeur
	DLL_CALLEXE TmpFonction=NULL;
		TmpFonction=dll_loadfunc(filename,fonctionname);
		if((int)TmpFonction<1)  { MessageBox(0,"Impossible de charger la DLL","Erreur",0); exit((int)TmpFonction); }
		
		char ** token=NULL;
		// va retourner dans un tableau les params
		int nbtoken=motparmot(&token,params,chars)+1;

		// Prépare la liste des paramètres a envoyer au pointeur
		void ** paramsdll=(void**)malloc(nbtoken*sizeof(void*));
		for(int i=0; i<nbtoken; i++){
			paramsdll[i]=token[i];
		}
		// Appelle le pointeur
		calldll(nbtoken,paramsdll,TmpFonction);
}

int main(){
	// dll(nombre de paramètre,fichier dll, fonction,param...);
	// Exemple #1
	dll(2,"dll.dll","CallFuncExe","Un seul parametre","pour CallFuncExe");
	
	// dll2(nom dll,fonction dll,variable des paramètres, caracthère séparant les paramètres);
	// Exemple #2
	char param[]="Un simple char,peut faire l'affaire !";
	dll2("dll.dll","CallFuncExe",param,',');
	
	system("pause");
	return 1;
}

Conclusion :


Merci encore à edcba sur le réseau Epiknet pour la parti en ASM.
Si quelqu'un a l'équivalent de la fonction calldll(...); version C/C++ je suis preneur
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (Suisse00)