#include "stdafx.h"
#include "stdio.h"
#include "conio.h"

// WMDM includes
#include "mswmdm_i.c"
#include "mswmdm.h"
#include "sac.h"
#include "scclient.h"

int main(int argc, char* argv[])
{
	HRESULT hr;
	IComponentAuthenticate* pICompAuth;
	CSecureChannelClient *m_pSacClient = new CSecureChannelClient;
	IWMDeviceManager3* m_pIdvMgr = NULL;

	//these are generic keys
	BYTE abPVK[] = {0x00};
	BYTE abCert[] = {0x00};

	printf("MTP Enumeration\n");
	printf("===============\n");

	CoInitialize(NULL);

	// get an authentication interface
	hr = CoCreateInstance(CLSID_MediaDevMgr, NULL, CLSCTX_ALL ,IID_IComponentAuthenticate, (void **)&pICompAuth);
	if SUCCEEDED(hr)
	{
		// create a secure channel client certificate
		hr = m_pSacClient->SetCertificate(SAC_CERT_V1, (BYTE*) abCert, sizeof(abCert), (BYTE*) abPVK, sizeof(abPVK));
		if SUCCEEDED(hr)
		{
			// bind the authentication interface to the secure channel client
			m_pSacClient->SetInterface(pICompAuth);

			// trigger communication
			hr = m_pSacClient->Authenticate(SAC_PROTOCOL_V1);                    
			if SUCCEEDED(hr)
			{
				// get main interface to media device manager
				hr = pICompAuth->QueryInterface(IID_IWMDeviceManager2, (void**)&m_pIdvMgr);
				if SUCCEEDED(hr)
				{
					// we now have a media device manager interface...
					printf("Media device interface information:\n\n");

					// revision #
					DWORD tempDW;
					hr = m_pIdvMgr->GetRevision(&tempDW);
					if SUCCEEDED(hr) {
						printf("Revision number %d\n", tempDW);
					}

					// device count
					hr = m_pIdvMgr->GetDeviceCount(&tempDW);
					if SUCCEEDED(hr) {
						printf("Device count: %d\n", tempDW);
					}

					// enumerate devices...
					IWMDMEnumDevice *pIEnumDev;
					wchar_t pwsString[256];
					char ch[256];
					hr = m_pIdvMgr->EnumDevices2(&pIEnumDev);
					if SUCCEEDED(hr) {
						hr = pIEnumDev->Reset(); // Next will now return the first device
						if SUCCEEDED(hr) {
							printf("");
							IWMDMDevice3* pIDevice;
							unsigned long ulNumFetched;
							size_t ret;
							hr = pIEnumDev->Next(1, (IWMDMDevice **)&pIDevice, &ulNumFetched);
							while (SUCCEEDED(hr) && (hr != S_FALSE)) {
								// output device name
								hr = pIDevice->GetName(pwsString, 256);
								if SUCCEEDED(hr) {
									wcstombs_s(&ret, ch, 256, pwsString,_TRUNCATE);
									printf("Found device %s\n", ch);
								}

								// output device manufacturer
								hr = pIDevice->GetManufacturer(pwsString, 256);
								if SUCCEEDED(hr) {
									wcstombs_s(&ret, ch, 256, pwsString,_TRUNCATE);
									printf("  Device Manufacturer: %s\n", ch);
								}

								// output device type
								hr = pIDevice->GetType(&tempDW);
								if SUCCEEDED(hr) {
									printf("  Device supports the following attributes:\n");
									if (tempDW & WMDM_DEVICE_TYPE_PLAYBACK) {
										printf("    WMDM_DEVICE_TYPE_PLAYBACK\n");
									}
									if (tempDW & WMDM_DEVICE_TYPE_RECORD) {
										printf("    WMDM_DEVICE_TYPE_RECORD\n");
									}
									if (tempDW & WMDM_DEVICE_TYPE_DECODE) {
										printf("    WMDM_DEVICE_TYPE_DECODE\n");
									}
									if (tempDW & WMDM_DEVICE_TYPE_ENCODE) {
										printf("    WMDM_DEVICE_TYPE_ENCODE\n");
									}
									if (tempDW & WMDM_DEVICE_TYPE_STORAGE) {
										printf("    WMDM_DEVICE_TYPE_STORAGE\n");
									}
									if (tempDW & WMDM_DEVICE_TYPE_VIRTUAL) {
										printf("    WMDM_DEVICE_TYPE_VIRTUAL\n");
									}
									if (tempDW & WMDM_DEVICE_TYPE_SDMI) {
										printf("    WMDM_DEVICE_TYPE_SDMI\n");
									}
									if (tempDW & WMDM_DEVICE_TYPE_NONSDMI) {
										printf("    WMDM_DEVICE_TYPE_NONSDMI\n");
									}
									if (tempDW & WMDM_DEVICE_TYPE_NONREENTRANT) {
										printf("    WMDM_DEVICE_TYPE_NONREENTRANT\n");
									}
									if (tempDW & WMDM_DEVICE_TYPE_FILELISTRESYNC) {
										printf("    WMDM_DEVICE_TYPE_FILELISTRESYNC\n");
									}
									if (tempDW & WMDM_DEVICE_TYPE_VIEW_PREF_METADATAVIEW) {
										printf("    WMDM_DEVICE_TYPE_VIEW_PREF_METADATAVIEW\n");
									}
								}

								if (tempDW & WMDM_DEVICE_TYPE_STORAGE) {
									// get storage information
									IWMDMEnumStorage *pIEnumStorage = NULL;
									IWMDMEnumStorage *pIEnumFileStorage = NULL;
									IWMDMEnumStorage *pIEnumFileStorageL2 = NULL;
									IWMDMStorage *pIStorage = NULL;
									IWMDMStorage3 *pIFileStorage = NULL; 
									IWMDMStorage3 *pIFileStorage_L2 = NULL;
									_WAVEFORMATEX format;
									hr = pIDevice->EnumStorage(&pIEnumStorage);
									if SUCCEEDED(hr) {
										pIEnumStorage->Reset();
										hr = pIEnumStorage->Next(1, (IWMDMStorage **)&pIStorage, &ulNumFetched);
										while (SUCCEEDED(hr) && (hr != S_FALSE)) {
											pIStorage->GetName(pwsString, 256);
											if SUCCEEDED(hr) {
												wcstombs_s(&ret, ch, 256, pwsString,_TRUNCATE);
												printf("  Storage Name: %s\n", ch);
											}
											printf("  Storage attributes:\n");
											pIStorage->GetAttributes(&tempDW, &format);
											if (tempDW & WMDM_STORAGE_ATTR_FILESYSTEM) {
												printf("    FILESYSTEM\n");
											}
											if (tempDW & WMDM_STORAGE_ATTR_REMOVABLE) {
												printf("    REMOVABLE\n");
											}
											if (tempDW & WMDM_STORAGE_ATTR_FOLDERS) {
												printf("    FOLDERS\n");
											}
											if (tempDW & WMDM_STORAGE_ATTR_HAS_FILES) {
												printf("    HAS_FILES\n");
											}
											if (tempDW & WMDM_STORAGE_ATTR_HAS_FOLDERS) {
												printf("    HAS_FOLDERS\n");
											}
											if (tempDW & WMDM_STORAGE_ATTR_CANEDITMETADATA) {
												printf("    CANEDITMETADATA\n");
											}
											if (tempDW & WMDM_STORAGE_ATTR_VIRTUAL) {
												printf("    VIRTUAL\n");
											}
											if (tempDW & WMDM_STORAGE_IS_DEFAULT) {
												printf("    IS_DEFAULT\n");
											}
											if (tempDW & WMDM_STORAGE_CONTAINS_DEFAULT) {
												printf("    CONTAINS_DEFAULT\n");
											}

											hr = pIStorage->EnumStorage(&pIEnumFileStorage);
											if SUCCEEDED(hr) {
												printf("  Files:\n");
												pIEnumFileStorage->Reset();
												hr = pIEnumFileStorage->Next(1, (IWMDMStorage **)&pIFileStorage, &ulNumFetched);

												while (SUCCEEDED(hr) && hr != S_FALSE) {
													hr = pIFileStorage->GetName(pwsString, 256); 
													if SUCCEEDED(hr) {
														wcstombs_s(&ret, ch, 256, pwsString,_TRUNCATE);
														printf("    %s", ch);
													}
													hr = pIFileStorage->GetAttributes(&tempDW, &format);
													if SUCCEEDED(hr) {
														if (tempDW & WMDM_FILE_ATTR_FOLDER) {
															printf("/\n");
															hr = pIFileStorage->EnumStorage(&pIEnumFileStorageL2);
															if SUCCEEDED(hr) {
																pIEnumFileStorageL2->Reset();
																hr = pIEnumFileStorageL2->Next(1, (IWMDMStorage **)&pIFileStorage_L2, &ulNumFetched);

																while (SUCCEEDED(hr) && (hr != S_FALSE)) {
																	hr = pIFileStorage_L2->GetName(pwsString, 256);
																	if SUCCEEDED(hr) {
																		wcstombs_s(&ret, ch, 256, pwsString,_TRUNCATE);
																		hr = pIFileStorage_L2->GetAttributes(&tempDW, &format);
																		if SUCCEEDED(hr) {
																			if (tempDW & WMDM_FILE_ATTR_FOLDER) {
																				// don't print out secondary folders...
																			} else {
																				printf("      %s", ch);
																				if (tempDW & WMDM_FILE_ATTR_FILE) {
																					printf(", FILE");
																				}
																				if (tempDW & WMDM_FILE_ATTR_FOLDER) {
																					printf(", FOLDER");
																				}
																				if (tempDW & WMDM_FILE_ATTR_LINK) {
																					printf(", LINK");
																				}
																				if (tempDW & WMDM_FILE_ATTR_AUDIO) {
																					printf(", AUDIO");
																				}
																				if (tempDW & WMDM_FILE_ATTR_DATA) {
																					printf(", DATA");
																				}
																				if (tempDW & WMDM_FILE_ATTR_CANPLAY) {
																					printf(", CANPLAY");
																				}
																				if (tempDW & WMDM_FILE_ATTR_CANDELETE) {
																					printf(", CANDELETE");
																				}
																				if (tempDW & WMDM_FILE_ATTR_CANREAD) {
																					printf(", CANREAD");
																				}
																				if (tempDW & WMDM_FILE_ATTR_MUSIC) {
																					printf(", MUSIC");
																				}
																				if (tempDW & WMDM_FILE_ATTR_AUDIOBOOK) {
																					printf(", AUDIOBOOK");
																				}
																				if (tempDW & WMDM_FILE_ATTR_VIDEO) {
																					printf(", VIDEO");
																				}
																				if (tempDW & WMDM_FILE_ATTR_HIDDEN) {
																					printf(", HIDDEN");
																				}
																				if (tempDW & WMDM_FILE_ATTR_SYSTEM) {
																					printf(", SYSTEM");
																				}
																				if (tempDW & WMDM_FILE_ATTR_READONLY) {
																					printf(", READONLY");
																				}
																				printf("\n");
																			}
																		} else {
																			printf("\n");
																		}
																	}

																	hr = pIEnumFileStorageL2->Next(1, (IWMDMStorage **)&pIFileStorage_L2, &ulNumFetched);
																}

																pIEnumFileStorageL2->Release();
															}
														} else {
															printf("\n");
														}
													} else {
														printf("\n");
													}

													pIFileStorage->Release();

													hr = pIEnumFileStorage->Next(1, (IWMDMStorage **)&pIFileStorage, &ulNumFetched);
												}
												pIEnumFileStorage->Release();
											}


											hr = pIEnumStorage->Next(1, (IWMDMStorage **)&pIStorage, &ulNumFetched);
										}
										pIEnumStorage->Release();
									}
								}

								// move to next device
								hr = pIEnumDev->Next(1, (IWMDMDevice **)&pIDevice, &ulNumFetched);
							}
							pIEnumDev->Release();
						}
						m_pIdvMgr->Release();
					}
					pICompAuth->Release();
				}
			}
		}
	}

	char c = _getch();

	CoUninitialize();

	return 0;
}