 |
Club Builder Foro de C++Builder en español
|
| Ver tema anterior :: Ver tema siguiente |
| Autor |
Mensaje |
_Vicktor Invitado
|
Publicado: Dom 20 Jul, 2003 2:05 am Asunto: Inventario de Hardware automatizado (solucionado) |
|
|
Hola foro, aqui les explico mi duda:
Quiero hacer una aplicacion que logre obtener la siguiente informacion de cierto equipo:
Driver de:
-Video
-Sonido
-LAN
-Modem
-Monitor,etc
Modelo de Placa Madre.-
He visto recientemente una aplicacion q hace todo esto sin tener siquiera un cliente en el equipo remoto, como? no tengo idea,
En todo caso las respuestas me sirven tanto para el equipo local, como para uno remoto.
De antemano muchisimas gracias.... |
|
| Volver arriba |
|
 |
Tio LuisMi Invitado
|
Publicado: Dom 20 Jul, 2003 8:57 am Asunto: |
|
|
Hace tiempo, navegando por Internet encontre las "win32 classes" en la pagina de microsoft (http://msdn.microsoft.com/) en ellas explicaba como acceder a practicamente todo lo relacionado con windows, entre ellas todo lo que tiene que ver con el hardware. Intente utilizarlas pero no lo logre y desde entonces no he tenido tiempo de retomar la cuestion. De hecho ahora que ha salido el tema a ver si alguien explica como aplicarlas.
En fin empieza mirando por aqui.
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/sms/hh/sms/refsms22_3lir.asp
O bien en el buscador de la pagina de microsoft con "win32 classes".
Bueno que tengas suerte.
Y lo dicho a ver si alguien explica como utilizar las win32 classes. |
|
| Volver arriba |
|
 |
_Viktor Invitado
|
Publicado: Dom 20 Jul, 2003 7:09 pm Asunto: |
|
|
Gracias por tu respuesta, ya estoy leyendo....
| Cita: | De hecho ahora que ha salido el tema a ver si alguien explica como aplicarlas.
|
Si alguien por ahi sabe como utilizar esta informacion, agradeceria sus aportes
GRACIAS!! |
|
| Volver arriba |
|
 |
_Viktor Master


Registrado: 20 Jul 2003Mensajes: 463Ubicación: Santiago, Los Angeles - Chile
|
Publicado: Vie 17 Oct, 2003 5:35 am Asunto: |
|
|
Hola a todos, por fin he dado con una solucion, la publico por si le es de utilidad a alguien:
Solo necesitan 2 ListBox, 1 Memo, 1 Edit y un Button.-
| Código: |
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
#include "Unit2.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
#define sizIO_HEADER 28
#define sizDMA_HEADER 16
#define sizIRQ_HEADER 20
#define sizMEM_HEADER 32
#define MAX_DEV_LEN 1000
#define ResType_Mem 0x00000001
#define ResType_IO 0x00000002
#define ResType_DMA 0x00000003
#define ResType_IRQ 0x00000004
#define CR_SUCCESS 0
#define CR_NO_MORE_LOG_CONF 0x0000000E
#define CR_BUFFER_SMALL 0x0000001A
#define CR_NO_SUCH_VALUE (0x00000025)
#define CR_INVALID_DATA (0x0000001F)
HINSTANCE CfgMan=NULL;
typedef DWORD WINAPI
(* CM_Enumerate_Classes)(ULONG,LPGUID,ULONG);
typedef DWORD WINAPI
(* CM_Get_First_Log_Conf)(PDWORD,DWORD,ULONG);
typedef DWORD WINAPI
(* CM_Get_Next_Res_Des)(PDWORD,DWORD,ULONG,PULONG,ULONG);
typedef DWORD WINAPI
(* CM_Free_Log_Conf_Handle)(DWORD);
typedef DWORD WINAPI
(* CM_Free_Res_Des_Handle) (DWORD);
typedef DWORD WINAPI
(* CM_Get_Res_Des_Data)(DWORD,PVOID,ULONG,ULONG);
typedef DWORD WINAPI
(* CM_Get_Res_Des_Data_Size)(PULONG,DWORD,ULONG);
CM_Enumerate_Classes enumClasses=NULL;
CM_Get_First_Log_Conf GetFirstConf=NULL;
CM_Get_Next_Res_Des GetNextResDes=NULL;
CM_Free_Log_Conf_Handle FreeLogConfHandle=NULL;
CM_Free_Res_Des_Handle FreeResDesHandle=NULL;
CM_Get_Res_Des_Data GetResDesData=NULL;
CM_Get_Res_Des_Data_Size GetResDesDataSize=NULL;
bool FResourceOpen=false;
bool FExtractResource=false;
char* FBufForRes;
DWORD FResourceType;
DWORD CurrConf;
HDEVINFO FResDeviceInfoSet;
SP_DEVINFO_DATA FDeviceInfoData;
DWORD ResHandle;
DWORD PrevResHandle;
bool FNoResourses;
ULONG sizeResFu;
bool OpenResources(DWORD TypR,char* ClassName, int DeviceIndex)
{
if( FResourceOpen )
return false;
FExtractResource = false;
if(FBufForRes)delete []FBufForRes;
FBufForRes = 0;
if( (TypR != ResType_Mem) && (TypR != ResType_IO) &&
(TypR != ResType_DMA) && (TypR != ResType_IRQ) ) {
FResourceType = TypR;
FResourceOpen = true;
CurrConf = 0;
FResDeviceInfoSet = 0;
ResHandle = 0;
PrevResHandle = 0;
FNoResourses = true;
return false;
}
DWORD rs;
DWORD typeP;
GUID *guids;
DWORD RequiredSize = 0;
bool guidTest = false;
bool res=SetupDiClassGuidsFromNameA(ClassName,guids,RequiredSize,&RequiredSize);
if(RequiredSize==0)
{
return false;
}
if(!res)
{
guids=(GUID *)malloc(RequiredSize*sizeof(GUID));
res=SetupDiClassGuidsFromNameA(ClassName,guids,RequiredSize,&RequiredSize);
if(!res || RequiredSize==0)
{
realloc(guids,0);
return false;
}
}
for( int j=0; j<(int)RequiredSize; ++j ) {
FResDeviceInfoSet=SetupDiGetClassDevs(guids,NULL,NULL,DIGCF_PRESENT);
if( FResDeviceInfoSet == INVALID_HANDLE_VALUE )
continue;
guidTest = true;
break;
}
if( !guidTest ) {
FResourceType = TypR;
FResourceOpen = true;
CurrConf = 0;
FResDeviceInfoSet = 0;
ResHandle = 0;
PrevResHandle = 0;
realloc(guids,0);
return false;
}
int res1;
FDeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
res1 = SetupDiEnumDeviceInfo(FResDeviceInfoSet,DeviceIndex,&FDeviceInfoData);
if( !res1 ) {
SetupDiDestroyDeviceInfoList(FResDeviceInfoSet);
FResourceType = TypR;
FResourceOpen = true;
CurrConf = 0;
FResDeviceInfoSet = 0;
ResHandle = 0;
PrevResHandle = 0;
FNoResourses = true;
realloc(guids,0);
return false;
}
CurrConf = 0;
ResHandle = 0;
DWORD cmRes = GetFirstConf(&CurrConf,FDeviceInfoData.DevInst,0x00000002);
if( cmRes == CR_NO_MORE_LOG_CONF ) {
cmRes = GetFirstConf(&CurrConf,FDeviceInfoData.DevInst,0x00000003);
}
if( cmRes != CR_SUCCESS ) {
SetupDiDestroyDeviceInfoList(FResDeviceInfoSet);
CurrConf = 0;
FResDeviceInfoSet = 0;
ResHandle = 0;
PrevResHandle = 0;
FResourceType = TypR;
FResourceOpen = true;
FNoResourses = true;
realloc(guids,0);
return false;
}
cmRes = GetNextResDes(&ResHandle, CurrConf, TypR, NULL, 0);
if(cmRes == CR_SUCCESS) {
FResourceType = TypR;
FResourceOpen = true;
PrevResHandle = 0;
FNoResourses = false;
realloc(guids,0);
return true;
} else {
SetupDiDestroyDeviceInfoList(FResDeviceInfoSet);
CurrConf = 0;
FResDeviceInfoSet = 0;
ResHandle = 0;
PrevResHandle = 0;
FResourceType = TypR;
FResourceOpen = true;
FNoResourses = true;
realloc(guids,0);
return false;
}
}
bool GetResource(char *bufres, int sizeBuf)
{
if( FNoResourses )
return false;
if( !FExtractResource )
return false;
if( sizeBuf < sizeResFu )
return false;
memcpy(bufres, FBufForRes, sizeResFu);
delete []FBufForRes;
FBufForRes=0;
return true;
}
int ExtractResourceInfo(bool *NextResExist)
{
ULONG sizeRes=0;
if( FBufForRes )
{
delete [] FBufForRes;
FBufForRes=0;
}
if(FNoResourses) {
*NextResExist = false;
return false;
}
if( ResHandle == 0 ) {
*NextResExist = false;
return -1;
}
DWORD cmRes = GetResDesDataSize(&sizeRes,ResHandle,0);
if( cmRes != CR_SUCCESS ) {
*NextResExist = false;
return -2;
}
//int numres = 0;
sizeResFu = sizeRes;
FBufForRes = new char[sizeResFu];
cmRes = GetResDesData(ResHandle, FBufForRes, sizeResFu, 0);
if(cmRes == CR_BUFFER_SMALL )
return -5;
if(cmRes != CR_SUCCESS) {
*NextResExist = false;
return -4;
}
FExtractResource = true;
PrevResHandle = 0;
cmRes = GetNextResDes(&PrevResHandle, ResHandle, FResourceType, NULL, 0);
if( cmRes == CR_SUCCESS ) {
*NextResExist=true;
FreeResDesHandle(ResHandle);
ResHandle=PrevResHandle;
PrevResHandle=0;
} else {
*NextResExist = false;
FreeResDesHandle(ResHandle);
ResHandle = 0;
PrevResHandle = 0;
}
return sizeResFu;
}
bool CloseResources(void)
{
if(!FResourceOpen)
return false;
FResourceType = 0;
if(ResHandle) {
FreeResDesHandle(ResHandle);
ResHandle = 0;
}
if(CurrConf) {
FreeLogConfHandle(CurrConf);
CurrConf = 0;
}
if(FResDeviceInfoSet)
SetupDiDestroyDeviceInfoList(FResDeviceInfoSet);
FResourceOpen = false;
FNoResourses = true;
return true;
}
int EnumerateDevices(ULONG DeviceIndex, char *ClassName, char *DeviceName)
{
DWORD RequiredSize = 0;
GUID *guids;
HDEVINFO NewDeviceInfoSet;
SP_DEVINFO_DATA DeviceInfoData;
DWORD rs;
DWORD typeP;
bool res=SetupDiClassGuidsFromNameA(ClassName,guids,RequiredSize,&RequiredSize);
if(RequiredSize==0)
{
//íåâåðíîå èìÿ êëàññà:
*DeviceName=0;
return -2;
}
if(!res)
{
guids=(GUID *)malloc(RequiredSize*sizeof(GUID));
res=SetupDiClassGuidsFromNameA(ClassName,guids,RequiredSize,&RequiredSize);
if(!res || RequiredSize==0)
{
realloc(guids,0);
*DeviceName=0;
return -2;
}
}
NewDeviceInfoSet=SetupDiGetClassDevs(guids,NULL,NULL,DIGCF_PRESENT);
if( NewDeviceInfoSet == INVALID_HANDLE_VALUE )
if(!res)
{
realloc(guids,0);
*DeviceName=0;
return -3;
}
DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
res=SetupDiEnumDeviceInfo(NewDeviceInfoSet,DeviceIndex,&DeviceInfoData);
if(!res) {
SetupDiDestroyDeviceInfoList(NewDeviceInfoSet);
realloc(guids,0);
*DeviceName=0;
return -1;
}
if(!SetupDiGetDeviceRegistryPropertyA(NewDeviceInfoSet,&DeviceInfoData,
SPDRP_FRIENDLYNAME,&typeP,DeviceName,MAX_DEV_LEN,&rs) )
{
res = SetupDiGetDeviceRegistryPropertyA(NewDeviceInfoSet,
&DeviceInfoData,SPDRP_DEVICEDESC,&typeP,DeviceName,MAX_DEV_LEN,&rs);
if(!res){
SetupDiDestroyDeviceInfoList(NewDeviceInfoSet);
realloc(guids,0);
*DeviceName=0;
return -4;
}
}
realloc(guids,0);
return 0;
}
//---------------------------------------------------------------------------
HANDLE BeginEnumerateClasses(void)
{
if(CfgMan == NULL)CfgMan=LoadLibrary("cfgmgr32");
enumClasses=(CM_Enumerate_Classes)GetProcAddress(CfgMan,"CM_Enumerate_Classes");
return enumClasses;
}
int EnumerateClasses(ULONG ClassIndex, char* ClassName, char* ClassDescription, BOOL *DevicePresent)
{
GUID ClassGuid;
HDEVINFO NewDeviceInfoSet;
SP_DEVINFO_DATA DeviceInfoData;
DWORD result;
char *name=0;
bool resNam=false;
DWORD RequiredSize=0;
if(CfgMan == NULL || enumClasses == NULL)return -4;
result = enumClasses(ClassIndex,&ClassGuid,0);
if(result == CR_INVALID_DATA)
{
*DevicePresent=false;
*ClassName=0;
return -2;
}
if(result == CR_NO_SUCH_VALUE)
{
*DevicePresent=false;
*ClassName=0;
return -1;
}
if(result != CR_SUCCESS)
{
*DevicePresent=false;
*ClassName=0;
return -3;
}
resNam=SetupDiClassNameFromGuidA(&ClassGuid,name,RequiredSize,&RequiredSize);
if(RequiredSize > 0)
{
name=(char *)malloc(RequiredSize);
SetupDiClassNameFromGuidA(&ClassGuid,name,RequiredSize,&RequiredSize);
}
NewDeviceInfoSet=SetupDiGetClassDevs(
&ClassGuid,
NULL,
NULL,
DIGCF_PRESENT);
if(NewDeviceInfoSet == INVALID_HANDLE_VALUE)
{ *DevicePresent=false;
strcpy(ClassName,name);
return 0;}
int numD=0;
int res1;
DeviceInfoData.cbSize=sizeof(SP_DEVINFO_DATA);
res1=SetupDiEnumDeviceInfo(
NewDeviceInfoSet,
numD,
&DeviceInfoData);
if(!res1)
{
SetupDiDestroyDeviceInfoList(NewDeviceInfoSet);
*DevicePresent=false;
strcpy(ClassName,name);
realloc(name,0);
return 0;
}
HKEY KeyClass=SetupDiOpenClassRegKeyEx(
&ClassGuid,MAXIMUM_ALLOWED,DIOCR_INSTALLER,NULL,NULL);
LONG sizeB=1000;
LONG res=RegQueryValue(KeyClass,NULL,ClassDescription,&sizeB);
if(res)*ClassDescription=0;
SetupDiDestroyDeviceInfoList(NewDeviceInfoSet);
strcpy(ClassName,name);
realloc(name,0);
*DevicePresent=true;
return 0;
}
void EndEnumerateClasses(void)
{
enumClasses=NULL;
if(CfgMan != NULL)FreeLibrary(CfgMan);
CfgMan=NULL;
}
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
char* tmp;
for(int i=0; i<ListBox1->Items->Count; ++i)
{
tmp=(char *)ListBox1->Items->Objects[i];
free(tmp);
}
Close();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormActivate(TObject *Sender)
{
if(CfgMan == NULL)CfgMan=LoadLibrary("cfgmgr32");
if(CfgMan == NULL)
{
ShowMessage("cfgmgr32 íå çàãðóæàåòñÿ");
Application->Terminate();
return;
}
GetFirstConf = (CM_Get_First_Log_Conf)GetProcAddress(CfgMan,"CM_Get_First_Log_Conf");
GetNextResDes = (CM_Get_Next_Res_Des)GetProcAddress(CfgMan,"CM_Get_Next_Res_Des");
FreeLogConfHandle = (CM_Free_Log_Conf_Handle)GetProcAddress(CfgMan,"CM_Free_Log_Conf_Handle");
FreeResDesHandle = (CM_Free_Res_Des_Handle)GetProcAddress(CfgMan,"CM_Free_Res_Des_Handle");
GetResDesData = (CM_Get_Res_Des_Data)GetProcAddress(CfgMan,"CM_Get_Res_Des_Data");
GetResDesDataSize = (CM_Get_Res_Des_Data_Size)GetProcAddress(CfgMan,"CM_Get_Res_Des_Data_Size");
char *classes=0;
char *classesDescr=0;
classesDescr=(char*)malloc(1000);
BOOL DevExist;
BeginEnumerateClasses();
ULONG i=0;
while(true)
{
classes=(char*)malloc(1000);
int res=EnumerateClasses(i,classes,classesDescr,&DevExist);
if(res == -1)
{
free(classes);
break;
}
++i;
if(res < -1 || !DevExist)
{
free(classes);
continue;
}
classes=(char*)realloc(classes,strlen(classes)+1);
ListBox1->Items->AddObject(classesDescr,(TObject *)classes);
Repaint();
}
EndEnumerateClasses();
realloc(classesDescr,0);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ListBox1Click(TObject *Sender)
{
char *devices=0;
int Index=0;
if(ListBox1->ItemIndex == -1)return;
ListBox2->Hint="";
ListBox2->Clear();
Memo1->Clear();
ListBox2->Enabled=false;
ListBox1->Enabled=false;
Edit1->Text=AnsiString((char *)ListBox1->Items->Objects[ListBox1->ItemIndex]);
ListBox1->Hint=ListBox1->Items->Strings[ListBox1->ItemIndex];
devices=(char*)malloc(MAX_DEV_LEN);
while(true)
{
int result=EnumerateDevices(Index, Edit1->Text.c_str(), devices);
if(result == -1)break;
if(result == 0)
{
ListBox2->Items->AddObject(devices,(TObject *)Index);
Repaint();
}
Index++;
}
ListBox2->Enabled=true;
ListBox1->Enabled=true;
realloc(devices,0);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ListBox2Click(TObject *Sender)
{
Memo1->Clear();
bool NextResExist;
IO_RESOURCE *IoResource;
DMA_RESOURCE *DmaResource;
IRQ_RESOURCE *IrqResource;
MEM_RESOURCE *MemResource;
int size;
char buf[1000];
if(ListBox2->ItemIndex == -1)return;
ListBox2->Hint=ListBox2->Items->Strings[ListBox2->ItemIndex];
int DI=int((char *)ListBox2->Items->Objects[ListBox2->ItemIndex]);
if(OpenResources(ResType_Mem,Edit1->Text.c_str(),DI))
{
Memo1->Lines->Add("Memoria:");
do {
size=ExtractResourceInfo(&NextResExist);
if(size > 0) {
GetResource(buf, size);
MemResource=(MEM_RESOURCE*)buf;
Memo1->Lines->Add(IntToHex((int)MemResource->MEM_Header.MD_Alloc_Base,8)+ " - "+
IntToHex((int)MemResource->MEM_Header.MD_Alloc_End,8));
for( int i=0; i < ((size - sizMEM_HEADER)/MemResource->MEM_Header.MD_Type); ++i ) {
if(MemResource[i].MEM_Data->MR_Min != 0 && MemResource[i].MEM_Data->MR_Max !=0
&& ((unsigned int)MemResource[i].MEM_Data->MR_Min < (unsigned int)MemResource[i].MEM_Data->MR_Max))
Memo1->Lines->Add(IntToHex((int)MemResource[i].MEM_Data->MR_Min,8) + " - " +
IntToHex((int)MemResource[i].MEM_Data->MR_Max,8));}
}
}while(NextResExist);
}
CloseResources();
if(OpenResources(ResType_IO,Edit1->Text.c_str(),DI))
{
if(Memo1->Lines->Count)Memo1->Lines->Add("");
Memo1->Lines->Add("Puertos:");
do {
size=ExtractResourceInfo(&NextResExist);
if(size > 0) {
GetResource(buf, size);
IoResource=(IO_RESOURCE*)buf;
Memo1->Lines->Add(IntToHex((int)IoResource->IO_Header.IOD_Alloc_Base,4) + " - "+
IntToHex((int)IoResource->IO_Header.IOD_Alloc_End,4));
for(int i=0; i < ((size - sizIO_HEADER)/IoResource->IO_Header.IOD_Type); ++i ) {
if( IoResource[i].IO_Data->IOR_Min != 0 && IoResource->IO_Data->IOR_Max !=0 &&
(unsigned int)IoResource[i].IO_Data->IOR_Min < (unsigned int)IoResource->IO_Data->IOR_Max )
Memo1->Lines->Add(IntToHex((int)IoResource->IO_Data->IOR_Min,4) + " - " +
IntToHex((int)IoResource->IO_Data->IOR_Max,4));
};
};
} while( NextResExist );
CloseResources();
}
if(OpenResources(ResType_DMA,Edit1->Text.c_str(),DI))
do {
size=ExtractResourceInfo(&NextResExist);
if(size > 0) {
GetResource(buf, size);
DmaResource=(DMA_RESOURCE*)buf;
if(Memo1->Lines->Count)Memo1->Lines->Add("");
Memo1->Lines->Add("DMA Chan.: "+IntToStr(DmaResource->DMA_Header.DD_Alloc_Chan));
for( int i=0; i < ((size - sizDMA_HEADER)/DmaResource->DMA_Header.DD_Type); ++i ) {
if(DmaResource[i].DMA_Data->DR_Min != 0 && DmaResource->DMA_Data->DR_Max !=0)
Memo1->Lines->Add(IntToStr(DmaResource->DMA_Data->DR_Min) + " - " +
IntToStr(DmaResource->DMA_Data->DR_Max));
};
};
} while( NextResExist );
CloseResources();
if(OpenResources(ResType_IRQ,Edit1->Text.c_str(),DI))
{
if(Memo1->Lines->Count)Memo1->Lines->Add("");
Memo1->Lines->Add("IRQ:");
do {
size=ExtractResourceInfo(&NextResExist);
if(size > 0) {
GetResource(buf, size);
IrqResource=(IRQ_RESOURCE*)buf;
Memo1->Lines->Add(IntToStr(IrqResource->IRQ_Header.IRQD_Alloc_Num));
for( int i=0; i < ((size - sizIRQ_HEADER)/IrqResource->IRQ_Header.IRQD_Type); ++i ) {
if(IrqResource[i].IRQ_Data->IRQR_Min != 0 && IrqResource[i].IRQ_Data->IRQR_Max !=0 &&
IrqResource[i].IRQ_Data->IRQR_Min != IrqResource->IRQ_Header.IRQD_Alloc_Num &&
IrqResource[i].IRQ_Data->IRQR_Max != IrqResource->IRQ_Header.IRQD_Alloc_Num )
Memo1->Lines->Add(IntToStr(IrqResource->IRQ_Data->IRQR_Min) + " - " +
IntToStr(IrqResource->IRQ_Data->IRQR_Max));
};
};
} while(NextResExist);
}
CloseResources();
}
//---------------------------------------------------------------------------
|
Espero les sirva de algo
(Si alguien quiere el ejemplo: victor_yp@hotmail.com )
Saludos _________________ "Ser inteligente no es ser mas, solo equivocarse menos y no usar Visual Basic"
Atte.
Victor Yañez
Apoyen el Proyecto OpenSource del Club Builder. Ya tenemos componentes Listos!!! |
|
| Volver arriba |
|
 |
Gustav0 Invitado
|
Publicado: Mie 03 Mar, 2004 7:41 pm Asunto: Creo que falla |
|
|
Viktor:
Creo que le faltan algunas cosas al codigo que has publicado ya que lo he puespo a mi compilador y me marca varios errores, yo manejo el builder 5.0 uno de los errores, es que no encuentra la funcion:
| Código: | bool res=SetupDiClassGuidsFromNameA(ClassName,guids,RequiredSize,&RequiredSize); |
Si no es mucha la molestia puedes enviar tu programa a la siguiente direccion:
Gustdiaz@orbis.org.mx
Te lo agradeceria mucho. Bye |
|
| Volver arriba |
|
 |
|
|
No puedes publicar temas nuevos en este foro No puedes responder a temas en este foro No puedes editar tus mensajes en este foro No puedes borrar tus mensajes en este foro No puedes votar en las encuestas de este foro
|
© 2002–2026 Club Builder · Funciona con phpBB.
|