elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: AIO elhacker.NET 2021 Compilación herramientas análisis y desinfección malware


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  Equivalencia de función WINAPI unsigned int WINAPI myRun en Windows con Ubuntu
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Equivalencia de función WINAPI unsigned int WINAPI myRun en Windows con Ubuntu  (Leído 2,078 veces)
bertamax

Desconectado Desconectado

Mensajes: 40


Ver Perfil
Equivalencia de función WINAPI unsigned int WINAPI myRun en Windows con Ubuntu
« en: 5 Agosto 2010, 03:45 am »

Hola,

escribí lo mejor que pude el siguiente programa en Windows:

Código
  1. #include <stdio.h>
  2.  
  3. #include <string.h>
  4.  
  5. #include <windows.h>
  6.  
  7. #include <process.h>
  8.  
  9. #include <direct.h>
  10.  
  11. #include <stdlib.h>
  12.  
  13. #include <ctype.h>
  14.  
  15. #include <conio.h>
  16.  
  17. #define MAX_THREAD 1
  18.  
  19. #define BUFSIZE 4096
  20.  
  21. #define WIN32_LEAN_AND_MEAN
  22.  
  23. typedef struct {
  24.  
  25. char* filein;
  26.  
  27. char* palabra;
  28.  
  29.    CRITICAL_SECTION * wcs;
  30.  
  31. char* myset;
  32.  
  33. HANDLE* semaforo;
  34.  
  35. }param;
  36.  
  37. extern unsigned int WINAPI myRun(LPVOID lpParam);
  38.  
  39. void lock(CRITICAL_SECTION * cs);
  40.  
  41. void unlock(CRITICAL_SECTION * cs);
  42.  
  43. int elabora(char* path, char* palabra, HANDLE semaforo, char* myset, char* fileOut);
  44.  
  45. int busquedaPalabra(char* path, char* palabra, HANDLE sem, char* myset, CRITICAL_SECTION * wcs, HANDLE* semaforo);
  46.  
  47. void produceFileOut(char* fileOut, char* myset);
  48.  
  49. char *getPath(const char* filename);
  50.  
  51. int main (int argc, char* argv[]) {
  52.  
  53.   char* path = argv[1];
  54.  
  55.   char* palabra = argv[2];
  56.  
  57.   char* fileOut = argv[3];
  58.  
  59.   char* myset = " ";
  60.  
  61.   CRITICAL_SECTION * wcs;
  62.  
  63.   HANDLE semaforo;
  64.  
  65.   InitializeCriticalSection(&wcs);
  66.  
  67.   semaforo = CreateSemaphore(NULL, MAX_THREAD, MAX_THREAD, NULL);
  68.  
  69.   elabora(path, palabra, semaforo, myset, fileOut);
  70.  
  71.   CloseHandle(semaforo);
  72.  
  73.   DeleteCriticalSection(&wcs);
  74.  
  75.   return 0;
  76.  
  77. }
  78.  
  79. void lock(CRITICAL_SECTION * cs){
  80.  
  81. EnterCriticalSection(&cs);
  82.  
  83. }
  84.  
  85. void unlock(CRITICAL_SECTION * cs){
  86.  
  87. LeaveCriticalSection(&cs);
  88.  
  89. }
  90.  
  91. int elabora(char* path, char* palabra, HANDLE semaforo, char* myset, char* fileOut) {
  92.  
  93.    int i;
  94.  
  95. for(i=0; i < MAX_THREAD; i++ )
  96.  
  97. WaitForSingleObject(semaforo,INFINITE);
  98.  
  99. if(strlen(myset)==0)
  100.  
  101.        printf("La cadena a buscar no se encuentra en el directorio especificado \n");
  102.  
  103. else
  104.  
  105. produceFileOut(fileOut, myset);
  106.  
  107. return 0;
  108.  
  109. }
  110.  
  111. int busquedaPalabra(char* path, char* palabra, HANDLE sem, char* myset, CRITICAL_SECTION * wcs, HANDLE* semaforo) {
  112.  
  113.    HANDLE hthread;
  114.  
  115.    char *puntero;
  116.  
  117. char* dirname=getPath(path);
  118.  
  119. WIN32_FIND_DATA file1;
  120.  
  121. HANDLE fd=INVALID_HANDLE_VALUE ;
  122.  
  123.    strcat(dirname,"\\*");
  124.  
  125. fd=FindFirstFile(dirname,&file1);
  126.  
  127. if(fd==INVALID_HANDLE_VALUE )
  128.  
  129. return -1;
  130.  
  131. while(FindNextFile(fd,&file1)!=0) {
  132.  
  133. if((file1.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)!=0) {
  134.  
  135. if((strcmp(file1.cFileName,".")!=0) && (strcmp(file1.cFileName,"..")!=0)) {
  136.  
  137. char* subdir=dirname;
  138.  
  139.                size_t its=strlen(subdir);
  140.  
  141.                its--;
  142.  
  143.                puntero=(char *)malloc(its);
  144.  
  145.                strcpy(puntero, subdir);
  146.  
  147.                strcat(puntero, file1.cFileName);
  148.  
  149. busquedaPalabra(puntero,palabra,sem,myset,wcs,semaforo);
  150.  
  151.                free(puntero);
  152.  
  153. }
  154.  
  155. }
  156.  
  157. else {
  158.  
  159. char* nameF=dirname;
  160.  
  161.            size_t its=strlen(nameF);
  162.  
  163.            its--;
  164.  
  165.            puntero=(char*)malloc(its);
  166.  
  167.            strcpy(puntero, nameF);
  168.  
  169.            strcat(puntero, file1.cFileName);
  170.  
  171. WaitForSingleObject(semaforo,INFINITE);
  172.  
  173.            param.filein=puntero;
  174.  
  175.            param.palabra=palabra;
  176.  
  177.            param.myset=myset;
  178.  
  179.            param.wcs=wcs;
  180.  
  181.            param.semaforo=&semaforo;
  182.  
  183. hthread= (HANDLE)_beginthreadex(NULL,0,&myRun,(void *)(param),0,NULL );
  184.  
  185. CloseHandle(hthread);
  186.  
  187. }
  188.  
  189. }
  190.  
  191.    FindClose(fd);
  192.  
  193.    return 0;
  194.  
  195. }
  196.  
  197. void produceFileOut(char* fileOut, char* myset) {
  198.  
  199. FILE *fout;
  200.  
  201. fout = fopen (fileOut, "wt");
  202.  
  203. fwrite(myset, strlen(myset)+1, 1, fout);
  204.  
  205. fclose(fout);
  206.  
  207. }
  208.  
  209. char *getPath(const char* filename) {
  210.  
  211. DWORD   retval = 0;
  212.  
  213.    char   fullPath[BUFSIZE]=TEXT("");
  214.  
  215.    char valor;
  216.  
  217.    LPTSTR  lpszFilePart = NULL;
  218.  
  219. retval = GetFullPathName(filename, BUFSIZE, fullPath, &lpszFilePart);
  220.  
  221. valor= fullPath;
  222.  
  223. return valor;
  224.  
  225. }
  226.  
  227. unsigned int WINAPI myRun(LPVOID lpParam) {
  228.  
  229. Param *pa=lpParam;
  230.  
  231. char* pos;
  232.  
  233. char* s;
  234.  
  235. FILE *fin;
  236.  
  237.    char* ret;
  238.  
  239. fin = fopen(pa.filein(), "wt");
  240.  
  241. while(getline(fin,s)) {
  242.  
  243. pos= strchr(s, pa.palabra);
  244.  
  245. if (pos!=npos) {
  246.  
  247.            lock(*pa.wcs);
  248.  
  249.            ret=strcat(pa.myset, pa.filein);
  250.  
  251. break;
  252.  
  253. }
  254.  
  255. }
  256.  
  257.    unlock(*pa.wcs);
  258.  
  259. fclose(fin);
  260.  
  261. ReleaseSemaphore(*(pa.semaforo),1L,NULL);
  262.  
  263. return 0;
  264.  
  265. }


y como buenamente puedo lo paso a Ubuntu:

Código
  1. #include <stdio.h>
  2.  
  3. #include <string.h>
  4.  
  5. #include <stdlib.h>
  6. #include <assert.h>
  7. #include <pthread.h>
  8. #include <limits.h>
  9. #include <unistd.h>
  10. #include <semaphore.h>
  11. #include <sys/types.h>
  12. #include <errno.h>
  13. #include <sys/stat.h>
  14. #include <fcntl.h>
  15. #include <time.h>
  16. #include <dirent.h>
  17.  
  18. #define MAX_THREAD 1
  19.  
  20. #define BUFSIZE 4096
  21.  
  22. #define WIN32_LEAN_AND_MEAN
  23.  
  24. typedef struct {
  25.  
  26. char* filein;
  27.  
  28. char* palabra;
  29.  
  30.     pthread_mutex_t * wcs;
  31.  
  32. char* myset;
  33.  
  34. sem_t semaforo;
  35.  
  36. }param;
  37.  
  38. extern unsigned int WINAPI myRun(LPVOID lpParam);
  39.  
  40. void lock(pthread_mutex_t * cs);
  41.  
  42. void unlock(pthread_mutex_t * cs);
  43.  
  44. int elabora(char* path, char* palabra, sem_t semaforo, char* myset, char* fileOut);
  45.  
  46. int busquedaPalabra(char* path, char* palabra, sem_t sem, char* myset, pthread_mutex_t * wcs, sem_t semaforo);
  47.  
  48. void produceFileOut(char* fileOut, char* myset);
  49.  
  50. char *getPath(const char* filename);
  51.  
  52. int main (int argc, char* argv[]) {
  53.  
  54.   char* path = argv[1];
  55.  
  56.   char* palabra = argv[2];
  57.  
  58.   char* fileOut = argv[3];
  59.  
  60.   char* myset = " ";
  61.  
  62.   pthread_mutex_t * wcs;
  63.  
  64.   sem_t semaforo;
  65.  
  66.   pthread_mutex_init(&wcs);
  67.   sem_init(&semaforo, MAX_THREAD, NULL);
  68.  
  69.   elabora(path, palabra, semaforo, myset, fileOut);
  70.  
  71.   sem_post(&semaforo);
  72.  
  73.   pthread_mutex_destroy(&wcs);
  74.  
  75.   return 0;
  76.  
  77. }
  78.  
  79. void lock(pthread_mutex_t * cs){
  80.  
  81. pthread_mutex_lock(&cs);
  82.  
  83. }
  84.  
  85. void unlock(pthread_mutex_t * cs){
  86.  
  87. pthread_mutex_unlock(&cs);
  88.  
  89. }
  90.  
  91. int elabora(char* path, char* palabra, sem_t semaforo, char* myset, char* fileOut) {
  92.  
  93.    int i;
  94.  
  95. for(i=0; i < MAX_THREAD; i++ )
  96. wait(&semaforo);
  97.  
  98. if(strlen(myset)==0)
  99.  
  100.         printf("La cadena a buscar no se encuentra en el directorio especificado \n");
  101.  
  102. else
  103.  
  104. produceFileOut(fileOut, myset);
  105.  
  106. return 0;
  107.  
  108. }
  109.  
  110. int busquedaPalabra(char* path, char* palabra, HANDLE sem, char* myset, pthread_mutex_t * wcs, sem_t semaforo) {
  111.  
  112.    pthread_t hthread;
  113.  
  114.    char *puntero;
  115.  
  116.    char* dirname=getPath(path);
  117.    DIR file1;
  118.  
  119.    struct stat statbuf;
  120.    struct dirent *direntp;
  121.  
  122.    int fd=NULL;
  123.  
  124.    strcat(dirname,"\\*");
  125.  
  126.    fd=readdir(dirname,&file1);
  127.  
  128.    if(fd==NULL )
  129.  
  130. return -1;
  131.    direntp = readdir(file1);
  132.    stat(file1, &statbuf);
  133.  
  134.    while(readdir(fd,&file1)!=0) {
  135.  
  136. if(statbuf.st_mode & S_IFDIR) {
  137. if((direntp.d_name != 0) && (direntp.d_name != 0)) {
  138.  
  139. char* subdir=dirname;
  140.  
  141.                size_t its=strlen(subdir);
  142.  
  143.                its--;
  144.  
  145.                puntero=(char *)malloc(its);
  146.  
  147.                strcpy(puntero, subdir);
  148.  
  149.                strcat(puntero, file1.cFileName);
  150.  
  151. busquedaPalabra(puntero,palabra,sem,myset,wcs,semaforo);
  152.  
  153.                free(puntero);
  154.  
  155. }
  156. }
  157.  
  158. else {
  159.  
  160. char* nameF=dirname;
  161.  
  162.                size_t its=strlen(nameF);
  163.  
  164.            its--;
  165.  
  166.            puntero=(char*)malloc(its);
  167.  
  168.            strcpy(puntero, nameF);
  169.  
  170.            strcat(puntero, file1.cFileName);
  171.  
  172. wait(&semaforo);
  173.  
  174.                param.filein=puntero;
  175.  
  176.            param.palabra=palabra;
  177.  
  178.            param.myset=myset;
  179.  
  180.            param.wcs=wcs;
  181.  
  182.            param.semaforo=&semaforo;
  183. pthread_create((hthread, NULL, &myRun, (void *)(param)));
  184.  
  185. pthread_kill(hthread);
  186. }
  187.    }
  188.  
  189.    closedir(fd);
  190.  
  191.    return 0;
  192.  
  193. }
  194.  
  195. void produceFileOut(char* fileOut, char* myset) {
  196.  
  197. FILE *fout;
  198.  
  199. fout = fopen (fileOut, "wt");
  200.  
  201. fwrite(myset, strlen(myset)+1, 1, fout);
  202.  
  203. fclose(fout);
  204.  
  205. }
  206.  
  207. char *getPath(const char* filename) {
  208.    getcwd(filename,BUFSIZE);
  209.  
  210. }
  211.  
  212. unsigned int WINAPI myRun(LPVOID lpParam) {
  213.  
  214.    Param *pa=lpParam;
  215.  
  216.    char* pos;
  217.  
  218.    char* s;
  219.  
  220.    FILE *fin;
  221.  
  222.    char* ret;
  223.  
  224.    fin = fopen(pa.filein(), "wt");
  225.  
  226.    while(getline(fin,s)) {
  227.  
  228. pos= strchr(s, pa.palabra);
  229.  
  230. if (pos!=npos) {
  231.  
  232.            lock(*pa.wcs);
  233.  
  234.            ret=strcat(pa.myset, pa.filein);
  235.  
  236.          break;
  237.  
  238. }
  239.  
  240.    }
  241.  
  242.    unlock(*pa.wcs);
  243.  
  244.    fclose(fin);
  245.  
  246.    sem_destroy(*(pa.semaforo));
  247.  
  248.    return 0;
  249.  
  250. }
  251.  

El problema es que no se como sustituir la función WINAPI con alguna que funcione en ubuntu y tenga la misma funcionalidad, o adaptar el programa entero a ubuntu de la mejor manera posible.

Por cierto, el lenguaje de programación es C, no C++

Muchas gracias a todos.

Lh: Utiliza las etiquetas GeSHi para poner código.


« Última modificación: 5 Agosto 2010, 04:01 am por Littlehorse » En línea

Littlehorse
All the world's a stage
Moderador
***
Desconectado Desconectado

Mensajes: 2.714


Nie Dam Sie


Ver Perfil WWW
Re: Equivalencia de función WINAPI unsigned int WINAPI myRun en Windows con Ubuntu
« Respuesta #1 en: 5 Agosto 2010, 04:19 am »

WINAPI no es una función, en este caso es una macro predefinida que implica una convención de llamada. En este caso __stdcall.

Para mas información lee esto:

Calling conventions

y tendrás claro como seguir.

En cuanto al código en general, no lo he leído todo pero a simple vista podrías ordenarlo utilizando compilación condicional

Saludos


En línea

An expert is a man who has made all the mistakes which can be made, in a very narrow field.
bertamax

Desconectado Desconectado

Mensajes: 40


Ver Perfil
Re: Equivalencia de función WINAPI unsigned int WINAPI myRun en Windows con Ubuntu
« Respuesta #2 en: 7 Agosto 2010, 16:27 pm »

Gracias.

He aprendido mucho
En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Problemas con WinApi
Programación C/C++
Nobody12 0 2,227 Último mensaje 10 Enero 2011, 21:47 pm
por Nobody12
Sobre menu en winapi
Programación C/C++
d00ze13 2 3,090 Último mensaje 29 Marzo 2011, 17:46 pm
por d00ze13
ayuda con programa en c y winapi que lista los directorios en un listview
Programación C/C++
suchil 1 2,422 Último mensaje 7 Agosto 2011, 16:23 pm
por escabe
Funcion winapi tecla pulsada
Programación C/C++
d00ze13 3 2,065 Último mensaje 24 Noviembre 2011, 06:36 am
por BlackZeroX
Cual es mejor utilizar or por que WINAPI o CALLBACK en una funcion
Programación C/C++
sanenr 1 919 Último mensaje 28 Abril 2014, 02:42 am
por Eternal Idol
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines