SET LIBRARY TO Agetfilesummary
 ?AGETFILESUMMARY("Afilesummary", _samples+"WebServices\Northwind\NorthwindWebservice_Setup.msi")
 Display Memory Like Afilesummary
 ?Agetfilesummary("Afilesummary", Getfile("doc,xls"))
 Display Memory Like Afilesummary

// the code from http://support.microsoft.com/kb/ 186898 /en-us
// has been adapted for VFP fll library by Igor Nikiforov  2008 - 11 - 12 
// Creates an array containing information about files with summary resources 
// or about Compound Document Properties 
// Return Value
// Numeric. AGETFILESUMMARY( ) returns the number of elements in the array. 
// If any error occurs AGETFILESUMMARY( ) returns the error code.
// If the file you specify does not exist or does not contain summary resources,
// AGETFILESUMMARY( ) returns zero, and the array, if already created, remains unchanged.
// AGETFILESUMMARY(ArrayName, cFileName)
// ArrayName Specifies the name of the array in which the file information is placed. 
// cFileName Specifies the name, and optionally the path, of the target file.
// Note:
// If an array or variable with name ArrayName already exists,
// the array or a variable will be deleted and the new array will be created.
// The function will produce an error if ArrayName already existed as a Public variable or array.
// This is because the function can only release a private variable or array and when an attempt
// to create the new array is executed a "variable already exists" error will occur. 
// Therefore, It is recommended that the SYS( 2015 ) function be used to obtain a unique name
// for the array to be created.
// The resulting array can then be loaded into a table or copied to a local array then deleted.
// The array created will have the following structure: 
// Column  1  property's name, type Character
// Column 2 property's value type Character, Numeric, Date etc
// Column  3  .F. for built-in  property and .T. for Custom's property, type Logical
// Column 4 windows property's type such as  VT_ARRAY, VT_BLOB etc., type Character
// Error codes:
//   STG_E_FILENOTFOUND      - 2147287038  File not found
//   STG_E_FILEALREADYEXISTS - 2147286960  Not a compound file
// Example
// ?AGETFILESUMMARY("Afilesummary", _samples+"WebServices\Northwind\NorthwindWebservice_Setup.msi")
// Display Memory Like Afilesummary
// ?Agetfilesummary("Afilesummary", Getfile("doc,xls"))
// Display Memory Like Afilesummary


#define  VISUAL_STUDIO_DOT_NET   0   // to compile in Visual Stidio .Net VISUAL_STUDIO_DOT_NET must be  1 

#include <pro_ext.h>
#include <stdio.h>
#include <windows.h>
#include <ole2.h>
#include <locale.h>



#define   MAXALLOCMEMORY	   1024 	 
typedef unsigned short USHORT;


/**************************************************************
Create a ASCIIZ sting from Value passed parameter
***************************************************************/
void FAR NullTerminate(Value FAR *cVal)  {
	if (!_SetHandSize(cVal->ev_handle, cVal->ev_length +  1 ))
		_Error( 182 ); // "Insufficient memory"
	_HLock(cVal->ev_handle);
	((char FAR *) _HandToPtr(cVal->ev_handle))[cVal->ev_length] = '\0';
	_HUnLock(cVal->ev_handle);
}


void makecolumn(Locator FAR *ploc, Value FAR * pv, char FAR * ps, int ncol) {
	ploc->l_sub2 = ncol;
	pv->ev_type = 'C';
	pv->ev_length = _StrLen(ps);
	_MemMove(_HandToPtr(pv->ev_handle), ps, pv->ev_length);
	_Store(ploc, pv);
}

void makenumcolumn(Locator FAR *ploc, Value FAR * pv) {
	ploc->l_sub2 =  2 ;
	pv->ev_type = 'N';
	pv->ev_width =  20 ;
	pv->ev_length  =  4 ;
	_Store(ploc, pv);
}


void makeintcolumn(Locator FAR *ploc, Value FAR * pv) {
	ploc->l_sub2 =  2 ;
	pv->ev_type = 'I';
	pv->ev_width =  12 ;
	_Store(ploc, pv);
}

// Dumps simple PROPVARIANT values.
void DumpPropVariant(PROPVARIANT *pPropVar, Locator FAR *ploc, Value FAR * pv) {
	char * ps;

	if(pPropVar->vt & VT_ARRAY) { // Don't iterate arrays, just inform as an array.
		// _PutStr("(Array)\n");
		ploc->l_sub2 = 2;
		_Store(ploc, pv);
		ps = "VT_ARRAY";
		makecolumn(ploc, pv, ps, 4) ;
		return;
	}
	
	if(pPropVar->vt & VT_BYREF) {  	// Don't handle byref for simplicity, just inform byref.
		// _PutStr("(ByRef)\n");
		ploc->l_sub2 =  2 ;
		_Store(ploc, pv);
		ps = "VT_BYREF";
		makecolumn(ploc, pv, ps,  4 ) ;
		return;
	}
	
	// Switch types.
	switch(pPropVar->vt) {
	case VT_EMPTY:
		// _PutStr("(VT_EMPTY)\n");
		ploc->l_sub2 =  2 ;
		_Store(ploc, pv);
		ps = "VT_EMPTY";
		makecolumn(ploc, pv, ps,  4 ) ;
		break;
	case VT_NULL:
		// _PutStr("(VT_NULL)\n");
		ploc->l_sub2 =  2 ;
		_Store(ploc, pv);
		ps = "VT_NULL";
		makecolumn(ploc, pv, ps,  4 ) ;
		break;
	case VT_BLOB:
		//_PutStr("(VT_BLOB)\n");
		ploc->l_sub2 =  2 ;
		_Store(ploc, pv);
		ps = "VT_BLOB";
		makecolumn(ploc, pv, ps,  4 ) ;
		break;
	case VT_BOOL:
		// _PutStr(pPropVar->boolVal ? "(VT_BOOL) TRUE/YES" : " (VT_BOOL) FALSE/NO");
		ploc->l_sub2 =  2 ;
		if (pPropVar->boolVal)
			pv->ev_length =  1 ;
		_Store(ploc, pv);
		ps = "VT_BOOL";
		makecolumn(ploc, pv, ps,  4 ) ;	
		break;
	case VT_I2: //  2 -byte signed int.
		// printf("%d (VT_I2)\n", (int)pPropVar->iVal);
		// PutNumLong((int)pPropVar->iVal);
		pv->ev_long  = (int)pPropVar->iVal;
		makeintcolumn(ploc, pv) ;
		ps = "VT_I2";
		makecolumn(ploc, pv, ps,  4 ) ;
		break;
	case VT_I4: //  4 -byte signed int.
		// printf("%d (VT_I4)\n", (int)pPropVar->lVal);
		// PutNumLong(pPropVar->iVal);
		pv->ev_long  = (int)pPropVar->lVal;
		makeintcolumn(ploc, pv) ;
		ps = "VT_I4";
		makecolumn(ploc, pv, ps,  4 ) ;
		break;
	case VT_R4: //  4 -byte real.
		// printf("%.2lf (VT_R4)\n", (double)pPropVar->fltVal);
		pv->ev_real   = (double)pPropVar->fltVal;
		makenumcolumn(ploc, pv) ;
		
		ps = "VT_R4";
		makecolumn(ploc, pv, ps,  4 ) ;
		break;
	case VT_R8: //  8 -byte real.
		// printf("%.2lf (VT_R8)\n", (double)pPropVar->dblVal);
		pv->ev_real   = (double)pPropVar->dblVal;
		makenumcolumn(ploc, pv) ;
		
		ps = "VT_R8";
		makecolumn(ploc, pv, ps,  4 ) ;
		break;
	case VT_BSTR: // OLE Automation string.
		{
			// Translate into ASCII.
			char dbcs[MAXALLOCMEMORY];
			char *pbstr = (char *)pPropVar->bstrVal;
#if VISUAL_STUDIO_DOT_NET
			size_t i ;
			wcstombs_s(&i, dbcs, MAXALLOCMEMORY, pPropVar->bstrVal,	*((DWORD *)(pbstr- 4 )));
#else
			int i = wcstombs(dbcs, pPropVar->bstrVal, *((DWORD *)(pbstr- 4 )));
#endif	
			dbcs[i] =  0 ;
			// printf("%s (VT_BSTR)\n", dbcs);
			ps = "VT_BSTR";
			makecolumn(ploc, pv, ps,  4 ) ;
			ps = dbcs;
			makecolumn(ploc, pv, ps,  2 ) ;
		}
		break;
	case VT_LPSTR: // Null-terminated string.
		{
			//	_PutStr(pPropVar->pszVal);
			ps = "VT_LPSTR";
			makecolumn(ploc, pv, ps,  4 ) ;
			ps = pPropVar->pszVal;
			makecolumn(ploc, pv, ps,  2 ) ;
		}
		break;
	case VT_FILETIME:
		{
			FILETIME lft;
			FileTimeToLocalFileTime(&pPropVar->filetime, &lft);  
			SYSTEMTIME lst;
			FileTimeToSystemTime(&lft, &lst);
			ps = (char FAR *)_HandToPtr(pv->ev_handle);
			ploc->l_sub2 =  2 ;
			sprintf(ps, "{^%d-%02d-%02d %02d:%02d.%02d}\0", lst.wYear, lst.wMonth, lst.wDay, lst.wHour, lst.wMinute, lst.wSecond);
			
			Value  TmpVal ;
			if ( _Evaluate(&TmpVal, ps)== 0 ) {
				_Store(ploc, &TmpVal);
			}
			else {
				sprintf(ps, "%02d:%02d.%02d %s %02d/%02d/%d\0",
					 1 +(lst.wHour- 1 )% 12 , lst.wMinute, lst.wSecond,
					(lst.wHour>= 12 ) ? "pm" : "am",
					lst.wMonth, lst.wDay, lst.wYear);
				pv->ev_type = 'C';
				pv->ev_length = _StrLen(ps);
				_Store(ploc, pv);
			}
			ps = "VT_FILETIME";
			makecolumn(ploc, pv, ps,  4 ) ;
		}
		break;
	case VT_CF: // Clipboard format.
		ploc->l_sub2 =  2 ;
		_Store(ploc, pv);
		ps = "VT_CF";
		makecolumn(ploc, pv, ps,  4 ) ;
		break;
	default: // Unhandled type, consult wtypes.h's VARENUM structure.
		// printf("(Unhandled type: 0x%08lx)\n", pPropVar->vt);
		ploc->l_sub2 = 2;
		_Store(ploc, pv);
		ps = "Unhandled type";
		makecolumn(ploc, pv, ps, 4) ;
		break;
	}
}

// Dump's built-in properties of a property storage.
unsigned long DumpBuiltInProps(IPropertySetStorage *pPropSetStg, Locator FAR *ploc) {
	IPropertyStorage *pPropStg = NULL;
	HRESULT hr;
	
	// Open summary information, getting an IpropertyStorage.
	hr = pPropSetStg->Open(FMTID_SummaryInformation, STGM_READ | STGM_SHARE_EXCLUSIVE, &pPropStg);
	
	if(FAILED(hr)) {
		return  0 ; 		// "No Summary-Information."
	}
	
	// Array of PIDSI's you are interested in.
	struct pidsiStruct {
		char *name;
		long pidsi;
	} pidsiArr[] = {
		{"Title",            PIDSI_TITLE}, // VT_LPSTR
		{"Subject",          PIDSI_SUBJECT}, // ...
		{"Author",           PIDSI_AUTHOR},
		{"Keywords",         PIDSI_KEYWORDS},
		{"Comments",         PIDSI_COMMENTS},
		{"Template",         PIDSI_TEMPLATE},
		{"LastAuthor",       PIDSI_LASTAUTHOR},
		{"Revision Number",  PIDSI_REVNUMBER},
		{"Edit Time",        PIDSI_EDITTIME}, // VT_FILENAME (UTC)
		{"Last printed",     PIDSI_LASTPRINTED}, // ...
		{"Created",          PIDSI_CREATE_DTM},
		{"Last Saved",       PIDSI_LASTSAVE_DTM},
		{"Page Count",       PIDSI_PAGECOUNT}, // VT_I4
		{"Word Count",       PIDSI_WORDCOUNT}, // ...
		{"Char Count",       PIDSI_CHARCOUNT},
		{"Thumpnail",        PIDSI_THUMBNAIL}, // VT_CF
		{"AppName",          PIDSI_APPNAME}, // VT_LPSTR
		{"Doc Security",     PIDSI_DOC_SECURITY}, // VT_I4
		{0, 0}
	};
	// Count elements in pidsiArr.
	int nPidsi = 0;
	for(nPidsi=0; pidsiArr[nPidsi].name; nPidsi++);
	
	// Initialize PROPSPEC for the properties you want.
	PROPSPEC *pPropSpec = new PROPSPEC [nPidsi];
	PROPVARIANT *pPropVar = new PROPVARIANT [nPidsi];
	
	for(int i=0; i<nPidsi; i++) {
		ZeroMemory(&pPropSpec[i], sizeof(PROPSPEC));
		pPropSpec[i].ulKind = PRSPEC_PROPID;
		pPropSpec[i].propid = pidsiArr[i].pidsi;
	}
	
	
	// Read properties.
	hr = pPropStg->ReadMultiple(nPidsi, pPropSpec, pPropVar);
	
	if(FAILED(hr)) {
		return 0;  		// "IPropertyStg::ReadMultiple() failed"
	}
	else {
		if (ploc) {
			Value v;
			if ((v.ev_handle = _AllocHand(MAXALLOCMEMORY)) == 0)
				_Error(182); // "Insufficient memory"
			
			_HLock(v.ev_handle);
			
			for(int i=0; i<nPidsi; i++) {
				ploc->l_sub1 = i+1;
				for ( ploc->l_sub2 = 1; ploc->l_sub2 <= 4; ploc->l_sub2++) {
					v.ev_type = 'C';
					switch (ploc->l_sub2) {
					case 1 :
						v.ev_length  = _StrLen(pidsiArr[i].name) ;
						_MemMove(_HandToPtr(v.ev_handle), pidsiArr[i].name, v.ev_length);
						_Store(ploc, &v);
						break;
					case 3 :
						v.ev_type = 'L';
						v.ev_length  = 0;
						_Store(ploc, &v);
						break;
					default:
						break;
					}
				}
				DumpPropVariant(pPropVar + i, ploc, &v);
			} 
			
			_HUnLock(v.ev_handle);
			_FreeHand(v.ev_handle);
		}
	}
	
	// De-allocate memory.
	delete [] pPropVar;
	delete [] pPropSpec;
	
	// Release obtained interface.
	pPropStg->Release();
	
	return (unsigned long) nPidsi;
}

// Dump's custom properties of a property storage.
unsigned long DumpCustomProps(IPropertySetStorage *pPropSetStg,	 Locator *ploc, unsigned long lasrrowcounforCustomProps) {
	Value v;
	unsigned long j= 0 ;
	
	IPropertyStorage *pPropStg = NULL;
	HRESULT hr;
	IEnumSTATPROPSTG *pEnumProp;
	
	// Open User-Defined-Properties, getting an IpropertyStorage.
	hr = pPropSetStg->Open(FMTID_UserDefinedProperties,	STGM_READ | STGM_SHARE_EXCLUSIVE, &pPropStg);
	if(FAILED(hr)) {
		return  0 ; // "No User Defined Properties."
	}
	
	hr = pPropStg->Enum(&pEnumProp); // Get property enumerator.
	if(FAILED(hr)) {
		pPropStg->Release();
		return  0 ;  // "Couldn't enumerate custom properties."
	}
	
	// Enumerate properties.
	STATPROPSTG sps;
	ULONG fetched;
	PROPSPEC propSpec[1];
	PROPVARIANT propVar[1];
	
	
	if (ploc) {
		if ((v.ev_handle = _AllocHand(MAXALLOCMEMORY)) == 0)
			_Error(182); // "Insufficient memory"
		_HLock(v.ev_handle);
	}
	
	while(pEnumProp->Next(1, &sps, &fetched) == S_OK) {
		// Build a PROPSPEC for this property.
		ZeroMemory(&propSpec[0], sizeof(PROPSPEC));
		propSpec[0].ulKind = PRSPEC_PROPID;
		propSpec[0].propid = sps.propid;
		
		hr = pPropStg->ReadMultiple(1, &propSpec[0], &propVar[0]); // Read this property.
		
		if(!FAILED(hr)) {
			j++;
			
			if (ploc) {  
				// Translate Prop name into ASCII.
				char dbcs[MAXALLOCMEMORY];
				char *pbstr = (char *)sps.lpwstrName;
#if VISUAL_STUDIO_DOT_NET
				size_t i ;
				wcstombs_s(&i, dbcs, MAXALLOCMEMORY, sps.lpwstrName,	*((DWORD *)(pbstr-4)));
#else
				int i = wcstombs(dbcs, sps.lpwstrName,	*((DWORD *)(pbstr-4)));
#endif
				dbcs[i] = 0;
				ploc->l_sub1 = (USHORT)(lasrrowcounforCustomProps+j);
				
				for ( ploc->l_sub2 = 1; ploc->l_sub2 <= 4; ploc->l_sub2++) {
					v.ev_type = 'C';
					switch (ploc->l_sub2) {
					case 1 :
						v.ev_length  = _StrLen(dbcs) ;
						_MemMove(_HandToPtr(v.ev_handle), dbcs, v.ev_length);
						_Store(ploc, &v);
						break;
					case 3 :
						v.ev_type = 'L';
						v.ev_length  = 1; // this is custom's property
						_Store(ploc, &v);
						break;
					default:
						break;
					}
					
				}
				// Dump this property.
				DumpPropVariant(&propVar[0], ploc, &v);
			}
		}
	}
	
	if (ploc) {
		_HUnLock(v.ev_handle);
		_FreeHand(v.ev_handle);
	}
	// Release obtained interface.
	pEnumProp->Release();
	pPropStg->Release();
	
	return j;
}


void FAR agetfilesummary(ParamBlk FAR *parm ) { // Creates an array containing information about files with Windows summary resources 
	unsigned long rowcount = 0, lasrrowcounforCustomProps = 0;
	char FAR *varName;
	Locator loc;
	int errcode ;
	NTI nti;
	char FAR *filename;
	WCHAR wcFilename[MAXALLOCMEMORY];
	int i;
	
	NullTerminate(&parm->p[1].val);     // Convert to ASCIIZ
	_HLock(parm->p[1].val.ev_handle);
	
	filename = (char FAR *) _HandToPtr(parm->p[1].val.ev_handle);
	// Dump's custom and built-in properties of a compound document.
	setlocale( LC_ALL, "" );
	i = mbstowcs(wcFilename, filename, _StrLen(filename)); // Translate filename to Unicode.
	_HUnLock(parm->p[1].val.ev_handle);
	
	setlocale( LC_ALL, "C" );
	wcFilename[i] = 0;
	
	IStorage *pStorage = NULL;
	IPropertySetStorage *pPropSetStg = NULL;
	HRESULT hr;
	
	// Open the document as an OLE compound document.
	hr = ::StgOpenStorage(wcFilename, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, NULL, 0, &pStorage);
	
	if(FAILED(hr)) {
		/*
		if(hr == STG_E_FILENOTFOUND) 			// _UserError("File not found.");
			;
		else if(hr == STG_E_FILEALREADYEXISTS)  // _UserError("Not a compound file.");
			;
		else 	// _UserError("StgOpenStorage() failed ");
			;
        */
		_RetInt(hr, 20);
		return;
	}
	
	// Obtain the IPropertySetStorage interface.
	hr = pStorage->QueryInterface( IID_IPropertySetStorage, (void **)&pPropSetStg);
	
	if(FAILED(hr)) {  // "QI for IPropertySetStorage failed "
		pStorage->Release();
		_RetInt(hr, 20);
		return;
	}
	
	// Dump properties.
	lasrrowcounforCustomProps = rowcount = DumpBuiltInProps(pPropSetStg, (Locator FAR *)NULL);
	rowcount = rowcount + DumpCustomProps(pPropSetStg, (Locator FAR *)NULL, 0L);
	
	
	if (rowcount) {
		NullTerminate(&parm->p[0].val);     // Convert to ASCIIZ
		_HLock(parm->p[0].val.ev_handle);
		varName = (char FAR *) _HandToPtr(parm->p[0].val.ev_handle);
		
		// delete the array or a variable if they earlier existed
		if ((nti = _NameTableIndex(varName)) > -1) {
			if (_FindVar(nti, -1, &loc)) 
				if ((errcode =_Release(nti)) < 0)
					_Error(-errcode);
		}							  
		
		loc.l_subs = 2;
		loc.l_sub1 = (USHORT)rowcount;
		loc.l_sub2 = 4;
		// we create an array 
		// this function in version for 8.0 below, can place in the array 16250 words because the array has 4 columns and must have fewer than 65,000 elements.
		// in LCK versions 9.0 this function can place in the array  65000 words a maximum.
		// If is when the quantity of words exceeds the admissible quantity there will be an error message « Too many variables »
		
		if ((nti = _NewVar(varName, &loc, NV_PUBLIC)) < 0)  // or NV_PRIVATE
			_Error(-nti); 		// _NewVar() returns negative Visual FoxPro error number
		
		if (_FindVar(nti, -1, &loc)) {
			if (lasrrowcounforCustomProps)
				DumpBuiltInProps(pPropSetStg, &loc);
			DumpCustomProps(pPropSetStg, &loc, lasrrowcounforCustomProps);
		}
		_HUnLock(parm->p[0].val.ev_handle);
	}
	
	
	// Release obtained interfaces.
	pPropSetStg->Release();
	pStorage->Release();
	// ---------------------	
	
	_RetInt(rowcount, 10);
	return;
}


FoxInfo myFoxInfo[] = {
	{"AGETFILESUMMARY",(FPFI) agetfilesummary, 2, "C,C"},
};

extern "C" {
	FoxTable _FoxTable = {
		(FoxTable FAR *) 0 , sizeof(myFoxInfo) / sizeof(FoxInfo), myFoxInfo
	};
}

Web тут ни причем, этот подход можно использовать с локальными директориями, Intranet etc... 

   *** http://forums.microsoft.com/TechNet/ShowPost.aspx?PostID= 3435698 &SiteID= 17 
   *** http://svn.python.org/projects/sandbox/branches/MvL/msi/msilib.py
   *** http://blogs.msdn.com/mwade/archive/ 2006 / 12 / 28 /happy-holidays.aspx
Function GetMsiProperties
   Lparameters lcMsipackage, laProperty
   External Array laProperty
   Local loIns, loDatabaseMSI, loView, loRecord, lnI, lcPropName, lcRes
   lcRes = ""
   If .Not.File(lcMsipackage)
      Return ""
   Endif
   If Type([Createobject("WindowsInstaller.Installer")]) == "O"
      loIns = Createobject("WindowsInstaller.Installer")
      loDatabaseMSI = loIns.OpenDatabase(lcMsipackage,  0 )
      For lnI =  1  To  3 
         Dimension laProperty(lnI,  2 )
         lcPropName = Icase(lnI =  1 , 'ProductName', lnI =  2 , 'ProductCode', lnI =  3 , 'ProductVersion', 'ProductID')
         loView = loDatabaseMSI.OpenView("SELECT Value FROM Property WHERE Property = '"+Alltrim(lcPropName) +"'")
         loView.Execute()
         loRecord = loView.Fetch()
         * ?lcPropName, loRecord.StringData( 1 )
         laProperty(lnI,  1 ) = lcPropName
         laProperty(lnI,  2 ) = loRecord.StringData( 1 )
         * lcRes = lcRes +" "+ lcPropName+" = "+loRecord.StringData( 1 )
      Endfor
      *  loView = loDatabaseMSI.OpenView("SELECT  * FROM Property")  && Property,  Value,
      *  loView = loDatabaseMSI.OpenView("SELECT  * FROM _Tables")  && all tables
      *!*	      loView.Execute()
      *!*	      loRecord = loView.Fetch()
      *!*	      Do While .Not.Isnull(loRecord)
      *!*	         ?loRecord.StringData( 1 ), loRecord.StringData( 2 ), loRecord.StringData( 3 ),  loRecord.StringData( 4 )
      *!*	         loRecord = loView.Fetch()
      *!*	      Enddo
      loView.Close()
      Store Null To loRecord,  loView, loDatabaseMSI, loIns
   Endif
   * Return lcRes