示例#1
0
BOOL CConfigMsgLogDlg::OnInitDialog()
{
    CDialog::OnInitDialog();
    m_ChkbEnableLogOnConnect.SetCheck(m_bLogOnConnect == TRUE? BST_CHECKED : BST_UNCHECKED);
    m_odStartMsgID.vSetConfigData(IDC_EDIT_STARTMSGID);
    m_odStopMsgID.vSetConfigData(IDC_EDIT_STOPMSGID);
    m_odStartMsgID.vSetBase(BASE_HEXADECIMAL);
    m_odStopMsgID.vSetBase(BASE_HEXADECIMAL);
    m_odStartMsgID.vSetSigned(false);
    m_odStopMsgID.vSetSigned(false);

    vCreateFileList();
    if(m_eCurrBus == CAN || m_eCurrBus == J1939)
    {
        //Load channel combo box
        m_omComboChannel.ResetContent();
        if (NULL != GetICANDIL())
        {
            LPARAM lParam = 0;
            if (S_OK == GetICANDIL()->DILC_GetControllerParams(lParam, NULL, NUMBER_HW))
            {
                m_unChannelCount = (UINT)lParam;
            }
        }

        m_omComboChannel.InsertString(0, _("ALL"));
        for (UINT i = 1; i <= m_unChannelCount; i++)
        {
            CString omChannel;
            omChannel.Format("%d", i);
            m_omComboChannel.InsertString(i, omChannel.GetBuffer(MAX_PATH));
        }
        m_omComboChannel.SetCurSel(0);

    }

    else if(m_eCurrBus == LIN)
    {

        //Load channel combo box
        m_omComboChannel.ResetContent();
        if (NULL != GetILINDIL())
        {
            LPARAM lParam = 0;
            if (S_OK == GetILINDIL()->DILL_GetControllerParams(lParam, NULL, NUMBER_HW))
            {
                m_unChannelCount = (UINT)lParam;
            }
        }

        m_omComboChannel.InsertString(0, _("ALL"));
        for (UINT i = 1; i <= m_unChannelCount; i++)
        {
            CString omChannel;
            omChannel.Format("%d", i);
            m_omComboChannel.InsertString(i, omChannel.GetBuffer(MAX_PATH));
        }
        m_omComboChannel.SetCurSel(0);
    }

    USHORT LogBlocks = GetLoggingBlockCount();
    if (LogBlocks > 0)
    {
        for (USHORT i = 0; i < LogBlocks; i++)
        {
            SLOGINFO sLogObject;
            HANDLE hFind;
            WIN32_FIND_DATA FindData;
            CStdioFile omStdiofile;

            GetLoggingBlock(i, sLogObject);

            // check for valid log file
            CString strTempLog = sLogObject.m_sLogFileName;

            hFind = FindFirstFile(strTempLog, &FindData);

            if(hFind == INVALID_HANDLE_VALUE )//file not found
            {
                DWORD dError = GetLastError();
                if(dError == ERROR_FILE_NOT_FOUND)//file not found
                {
                    BOOL bFileOpen = omStdiofile.Open(strTempLog,
                                                      CFile::modeCreate | CFile::modeWrite | CFile::typeBinary);

                    if(bFileOpen == TRUE)///file created, add in the list
                    {
                        omStdiofile.Close();
                        AddNewItem_GUI(sLogObject, i);
                    }
                    else //not a valid file
                    {
                        RemoveLoggingBlock(i--); //remove the old log data
                        LogBlocks = GetLoggingBlockCount(); //refresh the log count
                    }
                }
                else //not a valid filepath / file folder is removed
                {
                    RemoveLoggingBlock(i--); //remove the old log data
                    LogBlocks = GetLoggingBlockCount(); //refresh the log count
                }
            }
            else ///file found add in the list
            {
                AddNewItem_GUI(sLogObject, i);
            }

        }
        m_nLogIndexSel = 0;
        if(m_omListLogFiles.GetItemCount() > 0 )//check for log files exists
        {
            m_omListLogFiles.SetItemState(m_nLogIndexSel,
                                          LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED);
        }
        else
        {
            vEnableDisableControls(FALSE);//disable controls if no log files exists
        }
    }
    else
    {
        vEnableDisableControls(FALSE);
    }

    SetWindowText(m_strCurrWndText);

    if (m_bLogON)
    {
        vEnableDisableControls(FALSE);

        if(m_omListLogFiles.GetItemCount()>0)
        {
            vUpdate_GUI_From_Datastore(0);
        }

        GetDlgItem(IDC_CBTN_ADDLOG)->EnableWindow(FALSE);
        GetDlgItem(IDC_CHECK_RESET_TIMESTAMP)->EnableWindow(FALSE);
        GetWindowText(m_strCurrWndText);
        m_strCurrWndText+=_(" - Read Only as Logging is ON");
        SetWindowText(m_strCurrWndText);

        // If Logging is on
        GetDlgItem(IDOK)->EnableWindow(FALSE);

        m_unDispUpdateTimerId = SetTimer(600, 600, NULL);
    }
    else
    {
        // PTV [1.6.4]
        // If Logging is on
        GetDlgItem(IDOK)->EnableWindow(TRUE);

        // PTV [1.6.4]
    }

    // Hide or show the Filters button in the dialog based on the protocol
    if (CAN == m_eCurrBus)
    {
        GetDlgItem(IDC_LOG_FILTER)->ShowWindow(1);
    }
    else if (J1939 == m_eCurrBus)
    {
        GetDlgItem(IDC_LOG_FILTER)->ShowWindow(0);
    }
    //Shashank
    else if(LIN == m_eCurrBus)
    {
        GetDlgItem(IDC_LOG_FILTER)->ShowWindow(0);
    }

    return TRUE;
}
void	TargetNode::Wildcards()
{
	TargetNode	*pTarget, *pTargetFile;
	if ( GetType() == TARGET_PROJECT )
		{
		GetNodeC()->Wildcards();
		GetNodeH()->Wildcards();
		pTarget = GetFirstChildPRJ();
		while ( pTarget )
			{
			 pTarget->Wildcards();
			 pTarget= pTarget->GetNext();
			}
		}
	else if ( GetType() == NODE_FILE_C || GetType() == NODE_FILE_H )
		{
		 char		szDrive						[_MAX_DRIVE	+1],	szFoundDrive[_MAX_DRIVE	+1];
		 char		szDir							[_MAX_DIR		+1],	szFoundDir	[_MAX_DIR		+1];
		 char		szFname						[_MAX_PATH	+1],	szFoundFname[_MAX_PATH	+1];
		 char		szExt							[_MAX_EXT		+1],	szFoundExt	[_MAX_EXT		+1];
		 char		szWildcardsPath		[_MAX_PATH	+1],	szFoundFile	[_MAX_DIR		+1];
		 char		szEmpty[] = "";

		 WIN32_FIND_DATA	FileFindData;

		 SetAllWorkFlagsToTrue();
		 while ( TRUE )
			{
			 pTargetFile = GetFirstChildTarget();
			 while ( pTargetFile )
			 {
				if ( pTargetFile-> GetWorkFlag() )
					{
					 _splitpath( pTargetFile->GetFileName(), szDrive, szDir, szFname, szExt );
					 if ( szFname[0] != '*' )
							break;
					}
				pTargetFile= pTargetFile->GetNext();
			 }
			 if ( pTargetFile == NULL )
				 break;

			 pTargetFile->SetWorkFlagToFalse();
			 _splitpath( pTargetFile->GetFilePath(), szFoundDrive, szFoundDir, szFoundFname, szFoundExt );
			 strcpy( szFoundFname, "*" );
			 _makepath( szWildcardsPath, szFoundDrive, szFoundDir, szFoundFname, szFoundExt );

			 int		nMatchedFiles=0, nNoMatchedFiles = 0;
			 HANDLE hFindFile = FindFirstFile( szWildcardsPath, &FileFindData );
			 if ( hFindFile != INVALID_HANDLE_VALUE )
			 do
			 	{
					 _makepath( szFoundFile, szFoundDrive, szFoundDir, FileFindData.cFileName, szEmpty );
					 pTarget = GetFirstChildTarget();
					 while ( pTarget )
					 {
						 if ( stricmp( pTarget->GetFilePath(), szFoundFile ) == 0 )
								break;
						 pTarget= pTarget->GetNext();
					 }
					 if ( pTarget )
						{
						 nMatchedFiles++;
						 pTarget->SetWorkFlagToFalse();
						}
					 else
						 nNoMatchedFiles++;
				}
			 while ( FindNextFile( hFindFile, &FileFindData ) );

			 if ( nMatchedFiles && (nNoMatchedFiles==0 || (nNoMatchedFiles*100)/nMatchedFiles<=50) )
				{
				 hFindFile = FindFirstFile( szWildcardsPath, &FileFindData );
				 do
					{
					 _makepath( szFoundFile, szFoundDrive, szFoundDir, FileFindData.cFileName, szEmpty );
					 pTarget = GetFirstChildTarget();
					 while ( pTarget )
					 {
						 if ( stricmp( pTarget->GetFilePath(), szFoundFile ) == 0 )
								break;
						 pTarget= pTarget->GetNext();
					 }
					 if ( pTarget )
							pTarget->SetDeleteFlag();
					 else	// szFoundFile is not matched to project's files, insert new one
						{
						 char*		pszPath = GetParentPRJ()->GetFilePath();
						 int			nPathLen = strlen( pszPath );

						 pTargetFile = new TargetNode (szFoundFile, this, GetFirstChildTarget()->GetType());
						 if ( strstr( pTargetFile->GetFilePath(), pszPath) )
							 pTargetFile->SetFileName( pTargetFile->GetFilePath() + nPathLen);
						 else
							 pTargetFile->SetFileName( pTargetFile->GetFilePath() );
						 pTargetFile->SetExclusionFlag();
						 pTargetFile->SetWorkFlagToFalse();
						}
					}
					while ( FindNextFile( hFindFile, &FileFindData ) );

					// ----------------- delete matched files
					pTargetFile = GetFirstChildTarget();
					BOOL	bFirstFlag = TRUE;
					while ( pTargetFile )
					{
						pTarget = pTargetFile->GetNext();
						if ( pTargetFile-> GetDeleteFlag() )
							{
							 if ( bFirstFlag )
							 {
								 _splitpath( pTargetFile->GetFileName(), szDrive, szDir, szFname, szExt );
								 strcpy( szFname, "*" );
								 _makepath( pTargetFile->GetFileName(), szDrive, szDir, szFname, szExt );
								 _splitpath( pTargetFile->GetFilePath(), szDrive, szDir, szFname, szExt );
								 strcpy( szFname, "*" );
								 _makepath( pTargetFile->GetFilePath(), szDrive, szDir, szFname, szExt );
								 bFirstFlag = FALSE;
							 }
							 else
								 delete pTargetFile;
							}
						pTargetFile= pTarget;
					}

				}	// if ( bFindAllFilesFlag )
			}	// while (TRUE )
	}	// else if ( GetType() == NODE_FILE_C || GetType() == NODE_FILE_H )
}
示例#3
0
int pcap_findalldevs_ex(const char *source, struct pcap_rmtauth *auth, pcap_if_t **alldevs, char *errbuf)
{
	int type;
	char name[PCAP_BUF_SIZE], path[PCAP_BUF_SIZE], filename[PCAP_BUF_SIZE];
	size_t pathlen;
	size_t stringlen;
	pcap_t *fp;
	char tmpstring[PCAP_BUF_SIZE + 1];		/* Needed to convert names and descriptions from 'old' syntax to the 'new' one */
	pcap_if_t *lastdev;	/* Last device in the pcap_if_t list */
	pcap_if_t *dev;		/* Device we're adding to the pcap_if_t list */

	/* List starts out empty. */
	(*alldevs) = NULL;
	lastdev = NULL;

	if (strlen(source) > PCAP_BUF_SIZE)
	{
		pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "The source string is too long. Cannot handle it correctly.");
		return -1;
	}

	/*
	 * Determine the type of the source (file, local, remote)
	 * There are some differences if pcap_findalldevs_ex() is called to list files and remote adapters.
	 * In the first case, the name of the directory we have to look into must be present (therefore
	 * the 'name' parameter of the pcap_parsesrcstr() is present).
	 * In the second case, the name of the adapter is not required (we need just the host). So, we have
	 * to use a first time this function to get the source type, and a second time to get the appropriate
	 * info, which depends on the source type.
	 */
	if (pcap_parsesrcstr(source, &type, NULL, NULL, NULL, errbuf) == -1)
		return -1;

	switch (type)
	{
	case PCAP_SRC_IFLOCAL:
		if (pcap_parsesrcstr(source, &type, NULL, NULL, NULL, errbuf) == -1)
			return -1;

		/* Initialize temporary string */
		tmpstring[PCAP_BUF_SIZE] = 0;

		/* The user wants to retrieve adapters from a local host */
		if (pcap_findalldevs(alldevs, errbuf) == -1)
			return -1;

		if (*alldevs == NULL)
		{
			pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
				"No interfaces found! Make sure libpcap/Npcap is properly installed"
				" on the local machine.");
			return -1;
		}

		/* Scan all the interfaces and modify name and description */
		/* This is a trick in order to avoid the re-implementation of the pcap_findalldevs here */
		dev = *alldevs;
		while (dev)
		{
			char *localdesc, *desc;

			/* Create the new device identifier */
			if (pcap_createsrcstr(tmpstring, PCAP_SRC_IFLOCAL, NULL, NULL, dev->name, errbuf) == -1)
				return -1;

			/* Delete the old pointer */
			free(dev->name);

			/* Make a copy of the new device identifier */
			dev->name = strdup(tmpstring);
			if (dev->name == NULL)
			{
				pcap_fmt_errmsg_for_errno(errbuf,
				    PCAP_ERRBUF_SIZE, errno,
				    "malloc() failed");
				pcap_freealldevs(*alldevs);
				return -1;
			}

			/*
			 * Create the description.
			 */
			if ((dev->description == NULL) || (dev->description[0] == 0))
				localdesc = dev->name;
			else
				localdesc = dev->description;
			if (pcap_asprintf(&desc, "%s '%s' %s",
			    PCAP_TEXT_SOURCE_ADAPTER, localdesc,
			    PCAP_TEXT_SOURCE_ON_LOCAL_HOST) == -1)
			{
				pcap_fmt_errmsg_for_errno(errbuf,
				    PCAP_ERRBUF_SIZE, errno,
				    "malloc() failed");
				pcap_freealldevs(*alldevs);
				return -1;
			}

			/* Now overwrite the description */
			free(dev->description);
			dev->description = desc;

			dev = dev->next;
		}

		return 0;

	case PCAP_SRC_FILE:
	{
#ifdef _WIN32
		WIN32_FIND_DATA filedata;
		HANDLE filehandle;
#else
		struct dirent *filedata;
		DIR *unixdir;
#endif

		if (pcap_parsesrcstr(source, &type, NULL, NULL, name, errbuf) == -1)
			return -1;

		/* Check that the filename is correct */
		stringlen = strlen(name);

		/* The directory must end with '\' in Win32 and '/' in UNIX */
#ifdef _WIN32
#define ENDING_CHAR '\\'
#else
#define ENDING_CHAR '/'
#endif

		if (name[stringlen - 1] != ENDING_CHAR)
		{
			name[stringlen] = ENDING_CHAR;
			name[stringlen + 1] = 0;

			stringlen++;
		}

		/* Save the path for future reference */
		pcap_snprintf(path, sizeof(path), "%s", name);
		pathlen = strlen(path);

#ifdef _WIN32
		/* To perform directory listing, Win32 must have an 'asterisk' as ending char */
		if (name[stringlen - 1] != '*')
		{
			name[stringlen] = '*';
			name[stringlen + 1] = 0;
		}

		filehandle = FindFirstFile(name, &filedata);

		if (filehandle == INVALID_HANDLE_VALUE)
		{
			pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "Error when listing files: does folder '%s' exist?", path);
			return -1;
		}

#else
		/* opening the folder */
		unixdir= opendir(path);

		/* get the first file into it */
		filedata= readdir(unixdir);

		if (filedata == NULL)
		{
			pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "Error when listing files: does folder '%s' exist?", path);
			return -1;
		}
#endif

		/* Add all files we find to the list. */
		do
		{
#ifdef _WIN32
			/* Skip the file if the pathname won't fit in the buffer */
			if (pathlen + strlen(filedata.cFileName) >= sizeof(filename))
				continue;
			pcap_snprintf(filename, sizeof(filename), "%s%s", path, filedata.cFileName);
#else
			if (pathlen + strlen(filedata->d_name) >= sizeof(filename))
				continue;
			pcap_snprintf(filename, sizeof(filename), "%s%s", path, filedata->d_name);
#endif

			fp = pcap_open_offline(filename, errbuf);

			if (fp)
			{
				/* allocate the main structure */
				dev = (pcap_if_t *)malloc(sizeof(pcap_if_t));
				if (dev == NULL)
				{
					pcap_fmt_errmsg_for_errno(errbuf,
					    PCAP_ERRBUF_SIZE, errno,
					    "malloc() failed");
					pcap_freealldevs(*alldevs);
					return -1;
				}

				/* Initialize the structure to 'zero' */
				memset(dev, 0, sizeof(pcap_if_t));

				/* Append it to the list. */
				if (lastdev == NULL)
				{
					/*
					 * List is empty, so it's also
					 * the first device.
					 */
					*alldevs = dev;
				}
				else
				{
					/*
					 * Append after the last device.
					 */
					lastdev->next = dev;
				}
				/* It's now the last device. */
				lastdev = dev;

				/* Create the new source identifier */
				if (pcap_createsrcstr(tmpstring, PCAP_SRC_FILE, NULL, NULL, filename, errbuf) == -1)
				{
					pcap_freealldevs(*alldevs);
					return -1;
				}

				dev->name = strdup(tmpstring);
				if (dev->name == NULL)
				{
					pcap_fmt_errmsg_for_errno(errbuf,
					    PCAP_ERRBUF_SIZE, errno,
					    "malloc() failed");
					pcap_freealldevs(*alldevs);
					return -1;
				}

				/*
				 * Create the description.
				 */
				if (pcap_asprintf(&dev->description,
				    "%s '%s' %s", PCAP_TEXT_SOURCE_FILE,
				    filename, PCAP_TEXT_SOURCE_ON_LOCAL_HOST) == -1)
				{
					pcap_fmt_errmsg_for_errno(errbuf,
					    PCAP_ERRBUF_SIZE, errno,
					    "malloc() failed");
					pcap_freealldevs(*alldevs);
					return -1;
				}

				pcap_close(fp);
			}
		}
#ifdef _WIN32
		while (FindNextFile(filehandle, &filedata) != 0);
#else
		while ( (filedata= readdir(unixdir)) != NULL);
#endif


#ifdef _WIN32
		/* Close the search handle. */
		FindClose(filehandle);
#endif

		return 0;
	}

	case PCAP_SRC_IFREMOTE:
		return pcap_findalldevs_ex_remote(source, auth, alldevs, errbuf);

	default:
		pcap_strlcpy(errbuf, "Source type not supported", PCAP_ERRBUF_SIZE);
		return -1;
	}
}
/** Finds the executable and parameter list associated with the
    provided extension. */
BOOL 
GetExecutableAndArgumentTemplateByExtention (
	LPCSTR extension, 
	LPSTR  executable,
	LPSTR  arguments ) {

	DWORD			last_error			= ERROR_SUCCESS;
	LONG			result,
					length;
    CHAR			value[MAX_PATH+1],
					key[MAX_PATH+1],
                    name[MAX_PATH+1],
                    uppercase[MAX_PATH+1],
                    default_verb[]      = "Open";
    LPSTR           verb                = NULL;
	HANDLE			found				= INVALID_HANDLE_VALUE;
	WIN32_FIND_DATA find_data;
	LPSTR			tmp, 
					start				= NULL;					
	BOOL			quoted				= FALSE,
					expanded			= FALSE,
					ok					= FALSE;

	__try {

        /* make sure the output buffers not contain any misleading 
        information, if we are to fail */
        executable[0] = '\0';
        if ( arguments ) {
            arguments[0] = '\0';
        }

		/* using the extension, find the script type (or program ID) */
		length = MAX_PATH;
		result = RegQueryValue (
			HKEY_CLASSES_ROOT,
			extension,
			(LPSTR) value, 
			&length );

		if ( ERROR_SUCCESS != result ) {

			last_error = result;

			dprintf (
                D_ALWAYS,
				"GetExecutableAndArgumentsByExtention: failed to find "
				"extension *%s in the registry (last-error = %d).\n",
				extension, 
				last_error );

			__leave;

		}

        /* Because some file types have /n/ verb handlers, there is
        no intelligent way we can choose which one to use.  The verb
        'Open' is the most common, but we allow the user define one
		if they want. */
        strcpy (
            uppercase, 
            extension + 1 );

        sprintf ( 
            name, 
            "OPEN_VERB_FOR_%s_FILES", 
            strupr ( uppercase ) );

        verb = param ( name );

        sprintf ( 
            key, 
            "%s\\Shell\\%s\\Command", 
            value, 
            verb ? verb : default_verb );

        if ( verb ) {
            free ( verb );
        }

        length = MAX_PATH;
	    result = RegQueryValue (
		    HKEY_CLASSES_ROOT,
		    key,
		    (LPSTR) value, 
		    &length );

        if ( ERROR_SUCCESS != result ) {

			last_error = result;

			dprintf (
                D_ALWAYS,
				"GetExecutableAndArgumentsByExtention: failed to "
				"find a suitable handler for files with extension "
				"'*%s'. (last-error = %d)\n",
				extension, 
				last_error );

			__leave;

		}

        /* we now have the command-line.  First, let's trim all the
		leading whitespace. */
		tmp = (LPSTR) value;

		/* strip leading spaces */
        while ( *tmp && isspace ( *tmp ) ) {
            tmp++;
        }

        /* we are now at the start of the executable's path */
		start = tmp;

        /* if the executable is surrounded by quotes, then we want to 
		ignore all whitespace until we see another quote--after that
		we will stop. */
		quoted = ( '"' == *start );

		/* step through the executable's path until we reach either
		the closing quote, a whitespace character or NULL. */
		if ( quoted ) {
			
			/* skip first quote because FindFirstFile() does not
			work if there are quotes surrounding a script name. */
			start = ++tmp;
			while ( *tmp && ( '"' != *tmp ) ) {
				tmp++;
			}			

        } else {

			start = tmp;
            while ( *tmp && !isspace ( *tmp ) ) {
                tmp++;
            }

        }

		/* null terminate at the closing quote, the first 
		whitespace character or at the end of the buffer. */
		*tmp = '\0';

        /* validate the executable's existence */
		found = FindFirstFile ( 
			start,
			&find_data );

		if ( INVALID_HANDLE_VALUE == found ) {

			last_error = GetLastError ();

			dprintf (
                D_ALWAYS,
				"GetExecutableAndArgumentsByExtention: failed to "
                "locate the executable, %s, to handle files "
                "with extension '*%s'. (last-error = %d)\n",
				start, 
				extension, 
				last_error );

			__leave;

		}

		/* clean-up after the script search */
		FindClose ( found );
		
		/* finally, copy the executable path */
		strcpy ( executable, start );

		/* if we have not already consumed the entire buffer, then
		copy the rest as the arguments to the executable */
		start = ++tmp;
		if ( arguments && value - start < length - 1 ) {
			
			/* strip leading space until we are at the start of the
			executable's arguments */
            while ( *start && isspace ( *start ) ) {
                start++;
            }

			/* make a copy of the arguments */
            strcpy ( arguments, start );

		}
		
		/* if we made it here, then we're all going to be ok */
		ok = TRUE;

	}
	__finally {

		/* propagate the last error to our caller */
		SetLastError ( ok ? ERROR_SUCCESS : last_error );

	};
	
	return ok;

}
示例#5
0
void CBINDInstallDlg::ProgramGroup(BOOL create) {
	TCHAR path[MAX_PATH], commonPath[MAX_PATH], fileloc[MAX_PATH], linkpath[MAX_PATH];
	HRESULT hres;
	IShellLink *psl = NULL;
	LPMALLOC pMalloc = NULL;
	ITEMIDLIST *itemList = NULL;

	HRESULT hr = SHGetMalloc(&pMalloc);
	if (hr != NOERROR) {
		MessageBox("Could not get a handle to Shell memory object");
		return;
	}

	hr = SHGetSpecialFolderLocation(m_hWnd, CSIDL_COMMON_PROGRAMS, &itemList);
	if (hr != NOERROR) {
		MessageBox("Could not get a handle to the Common Programs folder");
		if (itemList) {
			pMalloc->Free(itemList);
		}
		return;
	}

	hr = SHGetPathFromIDList(itemList, commonPath);
	pMalloc->Free(itemList);

	if (create) {
		sprintf(path, "%s\\ISC", commonPath);
		CreateDirectory(path, NULL);

		sprintf(path, "%s\\ISC\\BIND", commonPath);
		CreateDirectory(path, NULL);

		hres = CoInitialize(NULL);

		if (SUCCEEDED(hres)) {
			// Get a pointer to the IShellLink interface.
			hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (LPVOID *)&psl);
			if (SUCCEEDED(hres))
			{
				IPersistFile* ppf;
				sprintf(linkpath, "%s\\BINDCtrl.lnk", path);
				sprintf(fileloc, "%s\\BINDCtrl.exe", m_binDir);

				psl->SetPath(fileloc);
				psl->SetDescription("BIND Control Panel");

				hres = psl->QueryInterface(IID_IPersistFile, (void **)&ppf);
				if (SUCCEEDED(hres)) {
					WCHAR wsz[MAX_PATH];

					MultiByteToWideChar(CP_ACP, 0, linkpath, -1, wsz, MAX_PATH);
					hres = ppf->Save(wsz, TRUE);
					ppf->Release();
				}

				if (GetFileAttributes("readme.txt") != -1) {
					sprintf(fileloc, "%s\\Readme.txt", m_targetDir);
					sprintf(linkpath, "%s\\Readme.lnk", path);

					psl->SetPath(fileloc);
					psl->SetDescription("BIND Readme");

					hres = psl->QueryInterface(IID_IPersistFile, (void **)&ppf);
					if (SUCCEEDED(hres)) {
						WCHAR wsz[MAX_PATH];

						MultiByteToWideChar(CP_ACP, 0, linkpath, -1, wsz, MAX_PATH);
						hres = ppf->Save(wsz, TRUE);
						ppf->Release();
					}
					psl->Release();
				}
			}
			CoUninitialize();
		}
	}
	else {
		TCHAR filename[MAX_PATH];
		WIN32_FIND_DATA fd;

		sprintf(path, "%s\\ISC\\BIND", commonPath);

		sprintf(filename, "%s\\*.*", path);
		HANDLE hFind = FindFirstFile(filename, &fd);
		if (hFind != INVALID_HANDLE_VALUE) {
			do {
				if (strcmp(fd.cFileName, ".") && strcmp(fd.cFileName, "..")) {
					sprintf(filename, "%s\\%s", path, fd.cFileName);
					DeleteFile(filename);
				}
			} while (FindNextFile(hFind, &fd));
			FindClose(hFind);
		}
		RemoveDirectory(path);
		sprintf(path, "%s\\ISC", commonPath);
		RemoveDirectory(path);
	}
}
示例#6
0
VOID ServiceStart (DWORD dwArgc, LPTSTR *lpszArgv)
{
  char exe_path[MAX_PATH];
  char config_dir[MAX_PATH];
  char ext_string[16];
  char log_dir[MAX_PATH];
  char priority_string[64];
  char append_string[2];

  DWORD priority;
  bool append;

  ResetError ();

  if (!ReportStatusToSCMgr(SERVICE_START_PENDING, NO_ERROR, 3000))
    {
      MSG (M_ERR, "ReportStatusToSCMgr #1 failed");
      goto finish;
    }

  /*
   * Create our exit event
   */
  exit_event = create_event (EXIT_EVENT_NAME, false, false, true);
  if (!exit_event)
    {
      MSG (M_ERR, "CreateEvent failed");
      goto finish;
    }

  /*
   * If exit event is already signaled, it means we were not
   * shut down properly.
   */
  if (WaitForSingleObject (exit_event, 0) != WAIT_TIMEOUT)
    {
      MSG (M_ERR, "Exit event is already signaled -- we were not shut down properly");
      goto finish;
    }

  if (!ReportStatusToSCMgr(SERVICE_START_PENDING, NO_ERROR, 3000))
    {
      MSG (M_ERR, "ReportStatusToSCMgr #2 failed");
      goto finish;
    }

  /*
   * Read info from registry in key HKLM\SOFTWARE\OpenVPN
   */
  {
    HKEY openvpn_key;
    LONG status;
    DWORD len;
    DWORD type;

    static const char error_format_str[] =
      "Error querying registry key of type REG_SZ: HKLM\\" REG_KEY "\\%s";

    static const char error_format_dword[] =
      "Error querying registry key of type REG_DWORD: HKLM\\" REG_KEY "\\%s";

    status = RegOpenKeyEx(
			  HKEY_LOCAL_MACHINE,
			  REG_KEY,
			  0,
			  KEY_READ,
			  &openvpn_key);

    if (status != ERROR_SUCCESS)
      {
	SetLastError (status);
	MSG (M_SYSERR, "Registry key HKLM\\" REG_KEY " not found");
	goto finish;
      }

    /* get path to openvpn.exe */
    QUERY_REG_STRING ("exe_path", exe_path);

    /* get path to configuration directory */
    QUERY_REG_STRING ("config_dir", config_dir);

    /* get extension on configuration files */
    QUERY_REG_STRING ("config_ext", ext_string);

    /* get path to log directory */
    QUERY_REG_STRING ("log_dir", log_dir);

    /* get priority for spawned OpenVPN subprocesses */
    QUERY_REG_STRING ("priority", priority_string);

    /* should we truncate or append to logfile? */
    QUERY_REG_STRING ("log_append", append_string);

    RegCloseKey (openvpn_key);
  }

  /* set process priority */
  priority = NORMAL_PRIORITY_CLASS;
  if (!_stricmp (priority_string, "IDLE_PRIORITY_CLASS"))
    priority = IDLE_PRIORITY_CLASS;
  else if (!_stricmp (priority_string, "BELOW_NORMAL_PRIORITY_CLASS"))
    priority = BELOW_NORMAL_PRIORITY_CLASS;
  else if (!_stricmp (priority_string, "NORMAL_PRIORITY_CLASS"))
    priority = NORMAL_PRIORITY_CLASS;
  else if (!_stricmp (priority_string, "ABOVE_NORMAL_PRIORITY_CLASS"))
    priority = ABOVE_NORMAL_PRIORITY_CLASS;
  else if (!_stricmp (priority_string, "HIGH_PRIORITY_CLASS"))
    priority = HIGH_PRIORITY_CLASS;
  else
    {
      MSG (M_ERR, "Unknown priority name: %s", priority_string);
      goto finish;
    }

  /* set log file append/truncate flag */
  append = false;
  if (append_string[0] == '0')
    append = false;
  else if (append_string[0] == '1')
    append = true;
  else
    {
      MSG (M_ERR, "Log file append flag (given as '%s') must be '0' or '1'", append_string);
      goto finish;
    }

  /*
   * Instantiate an OpenVPN process for each configuration
   * file found.
   */
  {
    WIN32_FIND_DATA find_obj;
    HANDLE find_handle;
    BOOL more_files;
    char find_string[MAX_PATH];

    openvpn_snprintf (find_string, MAX_PATH, "%s\\*", config_dir);

    find_handle = FindFirstFile (find_string, &find_obj);
    if (find_handle == INVALID_HANDLE_VALUE)
      {
        MSG (M_ERR, "Cannot get configuration file list using: %s", find_string);
	goto finish;
      }

    /*
     * Loop over each config file
     */
    do {
      HANDLE log_handle = NULL;
      STARTUPINFO start_info;
      PROCESS_INFORMATION proc_info;
      struct security_attributes sa;
      char log_file[MAX_PATH];
      char log_path[MAX_PATH];
      char command_line[256];

      CLEAR (start_info);
      CLEAR (proc_info);
      CLEAR (sa);

      if (!ReportStatusToSCMgr(SERVICE_START_PENDING, NO_ERROR, 3000))
	{
	  MSG (M_ERR, "ReportStatusToSCMgr #3 failed");
	  FindClose (find_handle);
	  goto finish;
	}

      /* does file have the correct type and extension? */
      if (match (&find_obj, ext_string))
	{
	  /* get log file pathname */
	  if (!modext (log_file, sizeof (log_file), find_obj.cFileName, "log"))
	    {
	      MSG (M_ERR, "Cannot construct logfile name based on: %s", find_obj.cFileName);
	      FindClose (find_handle);
	      goto finish;
	    }
	  openvpn_snprintf (log_path, sizeof(log_path),
                            "%s\\%s", log_dir, log_file);

	  /* construct command line */
	  openvpn_snprintf (command_line, sizeof(command_line), PACKAGE " --service %s 1 --config \"%s\"",
		      EXIT_EVENT_NAME,
		      find_obj.cFileName);

	  /* Make security attributes struct for logfile handle so it can
	     be inherited. */
	  if (!init_security_attributes_allow_all (&sa))
	    {
	      MSG (M_SYSERR, "InitializeSecurityDescriptor start_" PACKAGE " failed");
	      goto finish;
	    }

	  /* open logfile as stdout/stderr for soon-to-be-spawned subprocess */
	  log_handle = CreateFile (log_path,
				   GENERIC_WRITE,
				   FILE_SHARE_READ,
				   &sa.sa,
				   append ? OPEN_ALWAYS : CREATE_ALWAYS,
				   FILE_ATTRIBUTE_NORMAL,
				   NULL);

	  if (log_handle == INVALID_HANDLE_VALUE)
	    {
	      MSG (M_SYSERR, "Cannot open logfile: %s", log_path);
	      FindClose (find_handle);
	      goto finish;
	    }

	  /* append to logfile? */
	  if (append)
	    {
	      if (SetFilePointer (log_handle, 0, NULL, FILE_END) == INVALID_SET_FILE_POINTER)
		{
		  MSG (M_SYSERR, "Cannot seek to end of logfile: %s", log_path);
		  FindClose (find_handle);
		  goto finish;
		}
	    }

	  /* fill in STARTUPINFO struct */
	  GetStartupInfo(&start_info);
	  start_info.cb = sizeof(start_info);
	  start_info.dwFlags = STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;
	  start_info.wShowWindow = SW_HIDE;
	  start_info.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
	  start_info.hStdOutput = start_info.hStdError = log_handle;

	  /* create an OpenVPN process for one config file */
	  if (!CreateProcess(exe_path,
			     command_line,
			     NULL,
			     NULL,
			     TRUE,
			     priority | CREATE_NEW_CONSOLE,
			     NULL,
			     config_dir,
			     &start_info,
			     &proc_info))
	    {
	      MSG (M_SYSERR, "CreateProcess failed, exe='%s' cmdline='%s' dir='%s'",
		   exe_path,
		   command_line,
		   config_dir);

	      FindClose (find_handle);
	      CloseHandle (log_handle);
	      goto finish;
	    }

	  /* close unneeded handles */
	  Sleep (1000); /* try to prevent race if we close logfile
			   handle before child process DUPs it */
	  if (!CloseHandle (proc_info.hProcess)
	      || !CloseHandle (proc_info.hThread)
	      || !CloseHandle (log_handle))
	    {
	      MSG (M_SYSERR, "CloseHandle failed");
	      goto finish;
	    }
	}

      /* more files to process? */
      more_files = FindNextFile (find_handle, &find_obj);

    } while (more_files);
    
    FindClose (find_handle);
  }

  /* we are now fully started */
  if (!ReportStatusToSCMgr(SERVICE_RUNNING, NO_ERROR, 0))
    {
      MSG (M_ERR, "ReportStatusToSCMgr SERVICE_RUNNING failed");
      goto finish;
    }

  /* wait for our shutdown signal */
  if (WaitForSingleObject (exit_event, INFINITE) != WAIT_OBJECT_0)
    {
      MSG (M_ERR, "wait for shutdown signal failed");
    }

 finish:
  ServiceStop ();
  if (exit_event)
    CloseHandle (exit_event);
}
示例#7
0
void parseheader(char *path)
{
    WIN32_FIND_DATA fd;
    HANDLE handle;
	int len = 0;
	char *listpath = (char*)calloc(strlen(path)+9,sizeof(char));
	FILE *list = NULL;
	int listoffset = 0, listsize = 0;
	
	strncpy(listpath, path, strlen(path)-1);
	strcat(listpath,"list.txt\0");
	list = fopen(listpath,"r");
	free(listpath);
	
	if(!list)
	{
		printf("Could not open list.txt\n");
		exit(-1);
	}
	
	while(!feof(list))
	{
		char str[512];
		
		fgets(str, 512, list);
		listfiles++;
	}
	rewind(list);
	
	offset = listfiles*8;
        
    handle = FindFirstFile(path,&fd);
    do 
    {
        if(strcmp(fd.cFileName,".") != 0 && strcmp(fd.cFileName,"..") != 0 && strcmp(fd.cFileName,"list.txt") != 0&& !(fd.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN))
        {
			FILE *infile = NULL;
			char *inpath = (char*)calloc(strlen(path)+strlen(fd.cFileName)+1,sizeof(char));
			
			if((offset%PADDING)!=0)
				offset += PADDING - (offset%PADDING);

			strncpy(inpath, path, strlen(path)-1);
			strcat(inpath,fd.cFileName);
			
			infile = fopen(inpath, "rb");
			if(!infile)
			{
				printf("Could not open %s\n",inpath);
				exit(1);
			}
			
			fseek(infile,0,SEEK_END);
			len = ftell(infile);
			fclose(infile);
			
			fscanf(list,"%08x %08x",&listoffset, &listsize);
			if(listsize == 0)
			{
				while(listsize == 0 && !feof(list))
				{
					fwrite(&offset,1,4,outfile);
					fwrite(&listsize,1,4,outfile);
					
					fscanf(list,"%08x %08x",&listoffset, &listsize);
				}
			}
			
			fwrite(&offset,1,4,outfile);
			fwrite(&len,1,4,outfile);
			
			offset += len;
			len = 0;
			free(inpath);
        }
    } while(FindNextFile(handle,&fd) != 0);
	
	fscanf(list,"%08x %08x",&listoffset, &listsize);
	if(listsize == 0)
	{
		while(listsize == 0 && !feof(list))
		{
			fwrite(&offset,1,4,outfile);
			fwrite(&listsize,1,4,outfile);
					
				
			fscanf(list,"%08x %08x",&listoffset, &listsize);
		}
	}
	
	if(!feof(list))
	{
		printf("Probably didn't have all of the required files\n");
	}
	
	fwrite(&offset,1,4,outfile);
	fwrite(&len,1,4,outfile);
	
	fclose(list);
}
示例#8
0
static void FillListBox()
{
	WIN32_FIND_DATA wfd;
	HANDLE hSearch;
	TCHAR szFilePath[MAX_PATH];
	TCHAR szFilePathSearch[MAX_PATH];
	TCHAR szFileName[MAX_PATH];
	TCHAR *PatchDesc = NULL;
	TCHAR PatchName[256];
	int nHandlePos = 0;
	
	TV_INSERTSTRUCT TvItem;
	
	memset(&TvItem, 0, sizeof(TvItem));
	TvItem.item.mask = TVIF_TEXT | TVIF_PARAM;
	TvItem.hInsertAfter = TVI_LAST;

	_stprintf(szFilePath, _T("%s%s\\"), szAppIpsPath, BurnDrvGetText(DRV_NAME));
	_stprintf(szFilePathSearch, _T("%s*.dat"), szFilePath);
	
	hSearch = FindFirstFile(szFilePathSearch, &wfd);

	if (hSearch != INVALID_HANDLE_VALUE) {
		int Done = 0;
		
		while (!Done ) {
			memset(szFileName, '\0', MAX_PATH);
			_stprintf(szFileName, _T("%s%s"), szFilePath, wfd.cFileName);
			
			FILE *fp = _tfopen(szFileName, _T("r"));
			if (fp) {
				PatchDesc = NULL;
				memset(PatchName, '\0', 256);
				
				PatchDesc = GetPatchDescByLangcode(fp, nIpsSelectedLanguage);
				// If not available - try English first
				if (PatchDesc == NULL) PatchDesc = GetPatchDescByLangcode(fp, 0);
				// Simplified Chinese is the reference language (should always be available!!)
				if (PatchDesc == NULL) PatchDesc = GetPatchDescByLangcode(fp, 1);
				
				for (unsigned int i = 0; i < _tcslen(PatchDesc); i++) {
					if (PatchDesc[i] == '\r' || PatchDesc[i] == '\n') break;
					PatchName[i] = PatchDesc[i];					
				}
				
				// Check for categories
				TCHAR *Tokens;
				int nNumTokens = 0;
				int nNumNodes = 0;
				TCHAR szCategory[256];
				unsigned int nPatchNameLength = _tcslen(PatchName);
								
				Tokens = _tcstok(PatchName, _T("/"));
				while (Tokens != NULL) {
					if (nNumTokens == 0) {
						int bAddItem = 1;
						// Check if item already exists
						nNumNodes = SendMessage(hIpsList, TVM_GETCOUNT, (WPARAM)0, (LPARAM)0);
						for (int i = 0; i < nNumNodes; i++) {
							TCHAR Temp[256];
							TVITEM Tvi;
							memset(&Tvi, 0, sizeof(Tvi));
							Tvi.hItem = hItemHandles[i];
							Tvi.mask = TVIF_TEXT | TVIF_HANDLE;
							Tvi.pszText = Temp;
							Tvi.cchTextMax = 256;
							SendMessage(hIpsList, TVM_GETITEM, (WPARAM)0, (LPARAM)&Tvi);

							if (!_tcsicmp(Tvi.pszText, Tokens)) bAddItem = 0;
						}
						
						if (bAddItem) {
							TvItem.hParent = TVI_ROOT;
							TvItem.item.pszText = Tokens;
							hItemHandles[nHandlePos] = (HTREEITEM)SendMessage(hIpsList, TVM_INSERTITEM, 0, (LPARAM)&TvItem);
							nHandlePos++;
						}
						
						if (_tcslen(Tokens) == nPatchNameLength) {
							hPatchHandlesIndex[nPatchIndex] = hItemHandles[nHandlePos - 1];
							_tcscpy(szPatchFileNames[nPatchIndex], szFileName);
						
							nPatchIndex++;
						}
						
						_tcscpy(szCategory, Tokens);
					} else {
						HTREEITEM hNode = TVI_ROOT;
						// See which category we should be in
						nNumNodes = SendMessage(hIpsList, TVM_GETCOUNT, (WPARAM)0, (LPARAM)0);
						for (int i = 0; i < nNumNodes; i++) {
							TCHAR Temp[256];
							TVITEM Tvi;
							memset(&Tvi, 0, sizeof(Tvi));
							Tvi.hItem = hItemHandles[i];
							Tvi.mask = TVIF_TEXT | TVIF_HANDLE;
							Tvi.pszText = Temp;
							Tvi.cchTextMax = 256;
							SendMessage(hIpsList, TVM_GETITEM, (WPARAM)0, (LPARAM)&Tvi);

							if (!_tcsicmp(Tvi.pszText, szCategory)) hNode = Tvi.hItem;
						}
						
						TvItem.hParent = hNode;
						TvItem.item.pszText = Tokens;
						hItemHandles[nHandlePos] = (HTREEITEM)SendMessage(hIpsList, TVM_INSERTITEM, 0, (LPARAM)&TvItem);
												
						hPatchHandlesIndex[nPatchIndex] = hItemHandles[nHandlePos];
						_tcscpy(szPatchFileNames[nPatchIndex], szFileName);
						
						nHandlePos++;
						nPatchIndex++;
					}
					
					Tokens = _tcstok(NULL, _T("/"));
					nNumTokens++;
				}
				
				fclose(fp);
			}

			Done = !FindNextFile(hSearch, &wfd);
		}

		FindClose(hSearch);
	}
	
	nNumPatches = nPatchIndex;
	
	// Expand all branches
	int nNumNodes = SendMessage(hIpsList, TVM_GETCOUNT, (WPARAM)0, (LPARAM)0);;
	for (int i = 0; i < nNumNodes; i++) {
		SendMessage(hIpsList, TVM_EXPAND, TVE_EXPAND, (LPARAM)hItemHandles[i]);
	}
}
bool CSADirRead::GetSubDirs(CCOMList<CSADirEntry> &dir_array, const CCOMString &path)
{
	CCOMString newPath;

	CCOMString searchString;
	searchString = path;
	searchString+= "\\*.*";

   try 
   {
#ifndef USE_WIN32_FINDFILE
      struct _finddata_t  c_file;
      long fhandle;

      if ((fhandle=_findfirst( searchString, &c_file ))!=-1) 
      {
         // we only care about subdirs
         if ((c_file.attrib & _A_SUBDIR)==_A_SUBDIR) 
         {
            // add c_file.name to the string array
            
            // we'll handle parents on our own
            if ((strcmp(c_file.name, ".")!=0) && (strcmp(c_file.name, "..")!=0)) 
            {
               newPath = path;
               newPath+= "\\";
               newPath+= c_file.name;
               GetSubDirs(dir_array, newPath);
               
               dir_array.push_back(newPath);
            }
         }
         
         // find the rest of them	
         while(_findnext( fhandle, &c_file ) == 0 ) 
         {
            
            if ((c_file.attrib & _A_SUBDIR)==_A_SUBDIR) 
            {
               // we'll handle parents on our own
               if ((strcmp(c_file.name, ".")!=0) && (strcmp(c_file.name, "..")!=0)) 
               {
                  newPath = path;
                  newPath+= "\\";
                  newPath+= c_file.name;
                  GetSubDirs(dir_array, newPath);
                  dir_array.push_back(newPath);
               }
            }
         }
         _findclose(fhandle);
      }
#else
      WIN32_FIND_DATA FindFileData;
      HANDLE hFind;
      if ((hFind = FindFirstFile(searchString, &FindFileData))!=INVALID_HANDLE_VALUE)
      {
         // we only care about files, not subdirs
         if ((FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)==FILE_ATTRIBUTE_DIRECTORY) 
         {
            // we'll handle parents on our own
            if ((strcmp(FindFileData.cFileName, ".")!=0) && (strcmp(FindFileData.cFileName, "..")!=0)) 
            {
               newPath = path;
               newPath+= "\\";
               newPath+=FindFileData.cFileName;
               GetSubDirs(dir_array, newPath);
               
               dir_array.push_back(newPath);
            }
         }
         
         // find the rest of them	
         while(FindNextFile( hFind, &FindFileData )) 
         {
            // we only care about files, not subdirs
            if ((FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)==FILE_ATTRIBUTE_DIRECTORY) 
            {
               // we'll handle parents on our own
               if ((strcmp(FindFileData.cFileName, ".")!=0) && (strcmp(FindFileData.cFileName, "..")!=0)) 
               {
                  newPath = path;
                  newPath+= "\\";
                  newPath+=FindFileData.cFileName;
                  GetSubDirs(dir_array, newPath);
                  
                  dir_array.push_back(newPath);
               }
               
            }
         }
      }
      FindClose(hFind);
#endif
   } 
   catch (...) 
   {
      return false;
   }
   
   return true;
}
示例#10
0
void CPlaylistItem::AutoLoadFiles()
{
    if (m_fns.IsEmpty()) {
        return;
    }

    const CAppSettings& s = AfxGetAppSettings();

    CString fn = m_fns.GetHead();

    if (s.fAutoloadAudio && fn.Find(_T("://")) < 0) {
        int i = fn.ReverseFind('.');
        if (i > 0) {
            const CMediaFormats& mf = s.m_Formats;

            CString ext = fn.Mid(i + 1).MakeLower();

            if (!mf.FindExt(ext, true)) {
                CString path = fn;
                path.Replace('/', '\\');
                path = path.Left(path.ReverseFind('\\') + 1);

                WIN32_FIND_DATA fd;
                ZeroMemory(&fd, sizeof(WIN32_FIND_DATA));
                HANDLE hFind = FindFirstFile(fn.Left(i) + _T("*.*"), &fd);
                if (hFind != INVALID_HANDLE_VALUE) {
                    do {
                        if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
                            continue;
                        }

                        CString fullpath = path + fd.cFileName;
                        CString ext2 = fullpath.Mid(fullpath.ReverseFind('.') + 1).MakeLower();
                        if (!FindFileInList(m_fns, fullpath) && ext != ext2
                                && mf.FindExt(ext2, true) && mf.IsUsingEngine(fullpath, DirectShow)) {
                            m_fns.AddTail(fullpath);
                        }
                    } while (FindNextFile(hFind, &fd));

                    FindClose(hFind);
                }
            }
        }
    }

    if (s.IsISRAutoLoadEnabled()) {
        const CString& pathList = s.strSubtitlePaths;

        CAtlArray<CString> paths;

        int pos = 0;
        do {
            CString path = pathList.Tokenize(_T(";"), pos);
            if (!path.IsEmpty()) {
                paths.Add(path);
            }
        } while (pos != -1);

        CString dir = fn;
        dir.Replace('\\', '/');
        int l  = dir.ReverseFind('/') + 1;
        int l2 = dir.ReverseFind('.');
        if (l2 < l) { // no extension, read to the end
            l2 = fn.GetLength();
        }
        CString title = dir.Mid(l, l2 - l);
        paths.Add(title);

        CAtlArray<Subtitle::SubFile> ret;
        Subtitle::GetSubFileNames(fn, paths, ret);

        for (size_t i = 0; i < ret.GetCount(); i++) {
            if (!FindFileInList(m_subs, ret[i].fn)) {
                m_subs.AddTail(ret[i].fn);
            }
        }
    }
}
示例#11
0
int DeleteLogFiles()
{
   WIN32_FIND_DATA ffd;

   char szDir[MAX_PATH];
   char File[MAX_PATH];
   HANDLE hFind = INVALID_HANDLE_VALUE;
   DWORD dwError=0;
   LARGE_INTEGER ft;
   time_t now = time(NULL);
   int Age;

   // Prepare string for use with FindFile functions.  First, copy the
   // string to a buffer, then append '\*' to the directory name.

   strcpy(szDir, GetBPQDirectory());
   strcat(szDir, "\\logs\\Log_*.txt");

   // Find the first file in the directory.

   hFind = FindFirstFile(szDir, &ffd);

   if (INVALID_HANDLE_VALUE == hFind) 
   {
      return dwError;
   } 
   
   // List all the files in the directory with some info about them.

   do
   {
      if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
      {
         OutputDebugString(ffd.cFileName);
      }
      else
      {
         ft.HighPart = ffd.ftCreationTime.dwHighDateTime;
         ft.LowPart = ffd.ftCreationTime.dwLowDateTime;

		 ft.QuadPart -=  116444736000000000;
		 ft.QuadPart /= 10000000;

		 Age = (now - ft.LowPart) / 86400; 

		 if (Age > LogAge)
		 {
			 sprintf(File, "%s/logs/%s%c", GetBPQDirectory(), ffd.cFileName, 0);
			 if (DeletetoRecycleBin)
				DeletetoRecycle(File);
			 else
				 DeleteFile(File);
		 }
      }
   }
   while (FindNextFile(hFind, &ffd) != 0);
 
   dwError = GetLastError();

   FindClose(hFind);
   return dwError;
}
示例#12
0
//------------------------------------------------------------------------------
//format : http://www.forensicswiki.org/wiki/Windows_Prefetch_File_Format
DWORD WINAPI Scan_prefetch(LPVOID lParam)
{
  sqlite3 *db = (sqlite3 *)db_scan;
  unsigned int session_id = current_session_id;

  #ifdef CMD_LINE_ONLY_NO_DB
  printf("\"Prefetch\";\"file\";\"path\";\"create_time\";\"last_update\";\"last_access\";\"count\";\"exec\";\"session_id\";\"depend\";\r\n");
  #endif
  //check if local or not :)
  HTREEITEM hitem = (HTREEITEM)SendMessage(htrv_files, TVM_GETNEXTITEM,(WPARAM)TVGN_CHILD, (LPARAM)TRV_HTREEITEM_CONF[FILES_TITLE_APPLI]);
  if (hitem!=NULL || !LOCAL_SCAN || WINE_OS)
  {
    if(!SQLITE_FULL_SPEED)sqlite3_exec(db,"BEGIN TRANSACTION;", NULL, NULL, NULL);
    char tmp_file_pref[MAX_PATH],ext[MAX_PATH];
    while(hitem!=NULL)
    {
      tmp_file_pref[0] = 0;
      ext[0]           = 0;
      GetTextFromTrv(hitem, tmp_file_pref, MAX_PATH);
      if (!strcmp("pf",extractExtFromFile(charToLowChar(tmp_file_pref), ext, MAX_PATH)))
        PfCheck(session_id, db, tmp_file_pref);

      hitem = (HTREEITEM)SendMessage(htrv_files, TVM_GETNEXTITEM,(WPARAM)TVGN_NEXT, (LPARAM)hitem);
    }

    if(!SQLITE_FULL_SPEED)sqlite3_exec(db,"END TRANSACTION;", NULL, NULL, NULL);
    h_thread_test[(unsigned int)lParam] = 0;
    check_treeview(htrv_test, H_tests[(unsigned int)lParam], TRV_STATE_UNCHECK);//db_scan
    return 0;
  }

  //init
  if(!SQLITE_FULL_SPEED)sqlite3_exec(db_scan,"BEGIN TRANSACTION;", NULL, NULL, NULL);

  //get system path
  char path[MAX_PATH] ="%WINDIR%\\Prefetch\\*.pf";
  ReplaceEnv("WINDIR",path,MAX_PATH);

  char path_f[MAX_PATH];

  WIN32_FIND_DATA data;
  HANDLE hfic = FindFirstFile(path, &data);
  if (hfic != INVALID_HANDLE_VALUE)
  {
    do
    {
      if((data.cFileName[0] == '.' && (data.cFileName[1] == 0 || data.cFileName[1] == '.')) || (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)){}
      else
      {
        strncpy(path_f,path,MAX_PATH);
        path_f[strlen(path_f)-4]=0;
        strncat(path_f,data.cFileName,MAX_PATH);
        strncat(path_f,"\0",MAX_PATH);

        PfCheck(session_id, db, path_f);
      }
    }while(FindNextFile (hfic,&data) && start_scan);
    FindClose(hfic);
  }

  if(!SQLITE_FULL_SPEED)sqlite3_exec(db_scan,"END TRANSACTION;", NULL, NULL, NULL);
  check_treeview(htrv_test, H_tests[(unsigned int)lParam], TRV_STATE_UNCHECK);//db_scan
  h_thread_test[(unsigned int)lParam] = 0;
  return 0;
}
示例#13
0
/*
 =======================================================================================================================
    Map_SaveFile
 =======================================================================================================================
 */
bool Map_SaveFile(const char *filename, bool use_region, bool autosave)
{
	entity_t	*e, *next;
	idStr		temp;
	int			count;
	brush_t		*b;
	idStr status;

	int len = strlen(filename);
	WIN32_FIND_DATA FileData;

	if (FindFirstFile(filename, &FileData) != INVALID_HANDLE_VALUE) {
		// the file exists;
		if (len > 0 && GetFileAttributes(filename) & FILE_ATTRIBUTE_READONLY) {
			g_pParentWnd->MessageBox("File is read only", "Read Only", MB_OK);
			return false;
		}
	}

	if (filename == NULL || len == 0 || (filename && stricmp(filename, "unnamed.map") == 0)) {
		CFileDialog dlgSave(FALSE,"map",NULL,OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,"Map Files (*.map)|*.map||",AfxGetMainWnd());

		if (dlgSave.DoModal() == IDOK) {
			filename = dlgSave.m_ofn.lpstrFile;
			strcpy(currentmap, filename);
		} else {
			return false;
		}
	}

	MEMORYSTATUSEX statex;
	statex.dwLength = sizeof(statex);
	GlobalMemoryStatusEx(&statex);

	if (statex.dwMemoryLoad > 95) {
		g_pParentWnd->MessageBox("Physical memory is over 95% utilized. Consider saving and restarting", "Memory");
	}

	CWaitDlg dlg;
	Pointfile_Clear();

	temp = filename;
	temp.BackSlashesToSlashes();

	if (!use_region) {
		idStr backup;
		backup = temp;
		backup.StripFileExtension();
		backup.SetFileExtension(".bak");

		if (_unlink(backup) != 0 && errno != 2) {   // errno 2 means the file doesn't exist, which we don't care about
			g_pParentWnd->MessageBox(va("Unable to delete %s: %s", backup.c_str(), strerror(errno)), "File Error");
		}

		if (rename(filename, backup) != 0) {
			g_pParentWnd->MessageBox(va("Unable to rename %s to %s: %s", filename, backup.c_str(), strerror(errno)), "File Error");
		}
	}

	common->Printf("Map_SaveFile: %s\n", filename);

	idStr mapFile;
	bool localFile = (strstr(filename, ":") != NULL);

	if (autosave || localFile) {
		mapFile = filename;
	} else {
		mapFile = fileSystem->OSPathToRelativePath(filename);
	}

	if (use_region) {
		AddRegionBrushes();
	}

	idMapFile map;
	world_entity->origin.Zero();
	idMapEntity *mapentity = EntityToMapEntity(world_entity, use_region, &dlg);
	dlg.SetText("Saving worldspawn...");
	map.AddEntity(mapentity);

	if (use_region) {
		idStr buf;
		sprintf(buf, "{\n\"classname\"    \"info_player_start\"\n\"origin\"\t \"%i %i %i\"\n\"angle\"\t \"%i\"\n}\n",
		        (int)g_pParentWnd->GetCamera()->Camera().origin[0],
		        (int)g_pParentWnd->GetCamera()->Camera().origin[1],
		        (int)g_pParentWnd->GetCamera()->Camera().origin[2],
		        (int)g_pParentWnd->GetCamera()->Camera().angles[YAW]);
		idLexer src(LEXFL_NOSTRINGCONCAT | LEXFL_NOSTRINGESCAPECHARS | LEXFL_ALLOWPATHNAMES);
		src.LoadMemory(buf, buf.Length(), "regionbuf");
		idMapEntity *playerstart = idMapEntity::Parse(src);
		map.AddEntity(playerstart);
	}

	count = -1;

	for (e = entities.next; e != &entities; e = next) {
		count++;
		next = e->next;

		if (e->brushes.onext == &e->brushes) {
			Entity_Free(e); // no brushes left, so remove it
		} else {
			if (use_region) {
				for (b = e->brushes.onext; b != &e->brushes; b = b->onext) {
					if (!Map_IsBrushFiltered(b)) {
						break;	// got one
					}
				}

				if (b == &e->brushes) {
					continue;		// nothing visible
				}

			}

			idVec3 origin;

			if (!GetVectorForKey(e, "origin", origin)) {
				idStr text;
				VectorSubtract(e->brushes.onext->mins, e->eclass->mins, origin);
				sprintf(text, "%i %i %i", (int)origin[0], (int)origin[1], (int)origin[2]);
				SetKeyValue(e, "origin", text);
			}

			if (use_region && !idStr::Icmp(ValueForKey(e, "classname"), "info_player_start")) {
				continue;
			}

			idStr classname = e->epairs.GetString("classname");
			sprintf(status, "Saving entity %i (%s)...", count, classname.c_str());
			dlg.SetText(status);

			map.AddEntity(EntityToMapEntity(e, use_region, &dlg));
			count++;
		}
	}

	mapFile.StripFileExtension();
	idStr mapExt = (use_region) ? ".reg" : ".map";
	sprintf(status, "Writing file %s.%s...", mapFile.c_str(), mapExt.c_str());
	dlg.SetText(status);
	map.Write(mapFile, mapExt, !(autosave || localFile));
	mapModified = 0;

	if (use_region) {
		RemoveRegionBrushes();
	}

	if (!strstr(temp, "autosave")) {
		Sys_SetTitle(temp);
	}

	Sys_Status("Saved.\n", 0);

	return true;
}
示例#14
0
static void FindFiles(std::vector<std::string>& matches, const std::string& datadir, const std::string& dir, const boost::regex &regexpattern, int flags)
{
#ifdef _WIN32
	WIN32_FIND_DATA wfd;
	HANDLE hFind = FindFirstFile((datadir + dir + "\\*").c_str(), &wfd);

	if (hFind != INVALID_HANDLE_VALUE) {
		do {
			if(strcmp(wfd.cFileName,".") && strcmp(wfd.cFileName ,"..")) {
				if(!(wfd.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)) {
					if ((flags & FileSystem::ONLY_DIRS) == 0) {
						if (boost::regex_match(wfd.cFileName, regexpattern)) {
							matches.push_back(dir + wfd.cFileName);
						}
					}
				} else {
					if (flags & FileSystem::INCLUDE_DIRS) {
						if (boost::regex_match(wfd.cFileName, regexpattern)) {
							matches.push_back(dir + wfd.cFileName + "\\");
						}
					}
					if (flags & FileSystem::RECURSE) {
						FindFiles(matches, datadir, dir + wfd.cFileName + "\\", regexpattern, flags);
					}
				}
			}
		} while (FindNextFile(hFind, &wfd));
		FindClose(hFind);
	}
#else
	DIR* dp;
	struct dirent* ep;

	if (!(dp = opendir((datadir + dir).c_str()))) {
		return;
	}

	while ((ep = readdir(dp))) {
		// exclude hidden files
		if (ep->d_name[0] != '.') {
			// is it a file? (we just treat sockets / pipes / fifos / character&block devices as files...)
			// (need to stat because d_type is DT_UNKNOWN on linux :-/)
			struct stat info;
			if (stat((datadir + dir + ep->d_name).c_str(), &info) == 0) {
				if (!S_ISDIR(info.st_mode)) {
					if ((flags & FileSystem::ONLY_DIRS) == 0) {
						if (boost::regex_match(ep->d_name, regexpattern)) {
							matches.push_back(dir + ep->d_name);
						}
					}
				} else {
					// or a directory?
					if (flags & FileSystem::INCLUDE_DIRS) {
						if (boost::regex_match(ep->d_name, regexpattern)) {
							matches.push_back(dir + ep->d_name + "/");
						}
					}
					if (flags & FileSystem::RECURSE) {
						FindFiles(matches, datadir, dir + ep->d_name + "/", regexpattern, flags);
					}
				}
			}
		}
	}
	closedir(dp);
#endif
}
示例#15
0
VOID CompleteFilename (LPTSTR strIN, BOOL bNext, LPTSTR strOut, UINT cusor)
{
    /* Length of string before we complete it */
    INT_PTR StartLength;
    /* Length of string after completed */
    //INT EndLength;
    /* The number of chars added too it */
    //static INT DiffLength = 0;
    /* Used to find and assemble the string that is returned */
    TCHAR szBaseWord[MAX_PATH];
    TCHAR szPrefix[MAX_PATH];
    TCHAR szOrginal[MAX_PATH];
    TCHAR szSearchPath[MAX_PATH];
    /* Save the strings used last time, so if they hit tab again */
    static TCHAR LastReturned[MAX_PATH];
    static TCHAR LastSearch[MAX_PATH];
    static TCHAR LastPrefix[MAX_PATH];
    /* Used to search for files */
    HANDLE hFile;
    WIN32_FIND_DATA file;
    /* List of all the files */
    FileName * FileList = NULL;
    /* Number of files */
    INT FileListSize = 0;
    /* Used for loops */
    UINT i;
    /* Editable string of what was passed in */
    TCHAR str[MAX_PATH];
    /* Keeps track of what element was last selected */
    static INT Sel;
    BOOL NeededQuote = FALSE;
    BOOL ShowAll = TRUE;
    TCHAR * line = strIN;

    strOut[0] = _T('\0');

    while (_istspace (*line))
        line++;
    if (!_tcsnicmp (line, _T("rd "), 3) || !_tcsnicmp (line, _T("cd "), 3))
        ShowAll = FALSE;

    /* Copy the string, str can be edited and orginal should not be */
    _tcscpy(str,strIN);
    _tcscpy(szOrginal,strIN);

    /* Look to see if the cusor is not at the end of the string */
    if ((cusor + 1) < _tcslen(str))
        str[cusor] = _T('\0');

    /* Look to see if they hit tab again, if so cut off the diff length */
    if (_tcscmp(str,LastReturned) || !_tcslen(str))
    {
        /* We need to know how many chars we added from the start */
        StartLength = _tcslen(str);

        /* no string, we need all files in that directory */
        if (!StartLength)
        {
            _tcscat(str,_T("*"));
        }

        /* Zero it out first */
        szBaseWord[0] = _T('\0');
        szPrefix[0] = _T('\0');

        /*What comes out of this needs to be:
            szBaseWord =  path no quotes to the object
            szPrefix = what leads up to the filename
            no quote at the END of the full name */
        FindPrefixAndSuffix(str,szPrefix,szBaseWord);
        /* Strip quotes */
        for(i = 0; i < _tcslen(szBaseWord); )
        {
            if (szBaseWord[i] == _T('\"'))
                memmove(&szBaseWord[i],&szBaseWord[i + 1], _tcslen(&szBaseWord[i]) * sizeof(TCHAR));
            else
                i++;
        }

        /* clear it out */
        memset(szSearchPath, 0, sizeof(szSearchPath));

        /* Start the search for all the files */
        GetFullPathName(szBaseWord, MAX_PATH, szSearchPath, NULL);

        /* Got a device path? Fallback to the the current dir plus the short path */
        if (szSearchPath[0] == _T('\\') && szSearchPath[1] == _T('\\') &&
            szSearchPath[2] == _T('.') && szSearchPath[3] == _T('\\'))
        {
            GetCurrentDirectory(MAX_PATH, szSearchPath);
            _tcscat(szSearchPath, _T("\\"));
            _tcscat(szSearchPath, szBaseWord);
        }

        if (StartLength > 0)
        {
            _tcscat(szSearchPath,_T("*"));
        }
        _tcscpy(LastSearch,szSearchPath);
        _tcscpy(LastPrefix,szPrefix);
    }
    else
    {
        _tcscpy(szSearchPath, LastSearch);
        _tcscpy(szPrefix, LastPrefix);
        StartLength = 0;
    }
    /* search for the files it might be */
    hFile = FindFirstFile (szSearchPath, &file);
    if (hFile == INVALID_HANDLE_VALUE)
    {
        /* Assemble the orginal string and return */
        _tcscpy(strOut,szOrginal);
        return;
    }

    /* aseemble a list of all files names */
    do
    {
        FileName * oldFileList = FileList;

        if (!_tcscmp (file.cFileName, _T(".")) ||
            !_tcscmp (file.cFileName, _T("..")))
            continue;

        /* Don't show files when they are doing 'cd' or 'rd' */
        if (!ShowAll &&
            file.dwFileAttributes != 0xFFFFFFFF &&
            !(file.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
        {
                continue;
        }

        /* Add the file to the list of files */
        FileList = cmd_realloc(FileList, ++FileListSize * sizeof(FileName));

        if (FileList == NULL)
        {
            /* Don't leak old buffer */
            cmd_free(oldFileList);
            /* Assemble the orginal string and return */
            _tcscpy(strOut,szOrginal);
            FindClose(hFile);
            ConOutFormatMessage (GetLastError());
            return;
        }
        /* Copies the file name into the struct */
        _tcscpy(FileList[FileListSize-1].Name,file.cFileName);

    } while(FindNextFile(hFile,&file));

    FindClose(hFile);

    /* Check the size of the list to see if we
       found any matches */
    if (FileListSize == 0)
    {
        _tcscpy(strOut,szOrginal);
        if (FileList != NULL)
            cmd_free(FileList);
        return;

    }
    /* Sort the files */
    qsort(FileList,FileListSize,sizeof(FileName), compare);

    /* Find the next/previous */
    if (!_tcscmp(szOrginal,LastReturned))
    {
        if (bNext)
        {
            if (FileListSize - 1 == Sel)
                Sel = 0;
            else
                Sel++;
        }
        else
        {
            if (!Sel)
                Sel = FileListSize - 1;
            else
                Sel--;
        }
    }
    else
    {
        Sel = 0;
    }

    /* nothing found that matched last time
       so return the first thing in the list */
    strOut[0] = _T('\0');

    /* Special character in the name */
    if (FileNameContainsSpecialCharacters(FileList[Sel].Name))
    {
        INT LastSpace;
        BOOL bInside;
        /* It needs a " at the end */
        NeededQuote = TRUE;
        LastSpace = -1;
        bInside = FALSE;
        /* Find the place to put the " at the start */
        for(i = 0; i < _tcslen(szPrefix); i++)
        {
            if (szPrefix[i] == _T('\"'))
                bInside = !bInside;
            if (szPrefix[i] == _T(' ') && !bInside)
                LastSpace = i;
        }

        /* insert the quotation and move things around */
        if (szPrefix[LastSpace + 1] != _T('\"') && LastSpace != -1)
        {
            memmove ( &szPrefix[LastSpace+1], &szPrefix[LastSpace], (_tcslen(szPrefix)-LastSpace+1) * sizeof(TCHAR) );

            if ((UINT)(LastSpace + 1) == _tcslen(szPrefix))
            {
                _tcscat(szPrefix,_T("\""));
            }
            szPrefix[LastSpace + 1] = _T('\"');
        }
        else if (LastSpace == -1)
        {
            /* Add quotation only if none exists already */
            if (szPrefix[0] != _T('\"'))
            {
                _tcscpy(szBaseWord,_T("\""));
                _tcscat(szBaseWord,szPrefix);
                _tcscpy(szPrefix,szBaseWord);
            }
        }
    }

    _tcscpy(strOut,szPrefix);
    _tcscat(strOut,FileList[Sel].Name);

    /* check for odd number of quotes means we need to close them */
    if (!NeededQuote)
    {
        for(i = 0; i < _tcslen(strOut); i++)
        {
            if (strOut[i] == _T('\"'))
                NeededQuote = !NeededQuote;
        }
    }

    if (szPrefix[_tcslen(szPrefix) - 1] == _T('\"') || NeededQuote)
        _tcscat(strOut,_T("\""));

    _tcscpy(LastReturned,strOut);
    //EndLength = _tcslen(strOut);
    //DiffLength = EndLength - StartLength;
    if (FileList != NULL)
        cmd_free(FileList);
}
示例#16
0
UINT CSADirRead::FindFiles(const CCOMString & dir, const CCOMString & filter, bool bIncludeFilesInFileList, bool bIncludeFoldersInFileList)
{
	// make sure the path ends in a single "\"
	CCOMString baseName = dir;
	FormatPath(baseName);
	baseName+='\\';

	CCOMString fullPath = baseName;
	fullPath += filter;

	CCOMString fileName;

	// find first file in current directory
#ifndef USE_WIN32_FINDFILE
	struct _finddata_t  c_file;
	long fhandle;

	try 
	{
		if ((fhandle=_findfirst( fullPath, &c_file ))!=-1) 
		{
         bool bIsFolder = (c_file.attrib & _A_SUBDIR)==_A_SUBDIR;

         bool bAddThisOne = (bIsFolder && bIncludeFoldersInFileList) || (!bIsFolder && bIncludeFilesInFileList);

         // skip . and ..
         if (bIsFolder && (strcmp(c_file.name, ".")==0) || (strcmp(c_file.name, "..")==0))
         {
            bAddThisOne = false;
         }

         if (bAddThisOne) 
			{
				fileName = baseName;
				fileName += c_file.name;

				CSAFileEntry t;
            t.bIsFolder = bIsFolder;
            t.attrib = c_file.attrib;
				t.m_sName = fileName;
				t.time_write = c_file.time_write;
				t.time_create = c_file.time_create;
            t.size = c_file.size;
				m_files.push_back(t);
			}

			// find the rest of them	
			while(_findnext( fhandle, &c_file ) == 0 ) 
			{
            bool bIsFolder = (c_file.attrib & _A_SUBDIR)==_A_SUBDIR;
            bool bAddThisOne = (bIsFolder && bIncludeFoldersInFileList) || (!bIsFolder && bIncludeFilesInFileList);

            // skip . and ..
            if (bIsFolder && (strcmp(c_file.name, ".")==0) || (strcmp(c_file.name, "..")==0))
            {
               bAddThisOne = false;
            }

			   if (bAddThisOne) 
				{
					fileName=baseName;
					fileName += c_file.name;

					CSAFileEntry t;
               t.bIsFolder = bIsFolder;
               t.attrib = c_file.attrib;
					t.m_sName = fileName;
					t.time_write = c_file.time_write;
					t.time_create = c_file.time_create;
               t.size = c_file.size;
					m_files.push_back(t);
				}
			}
			_findclose(fhandle);
		}
	} 
	catch (...) 
	{
		return false;
	}
#else
   WIN32_FIND_DATA FindFileData;
   HANDLE hFind;
	try 
	{
		if ((hFind = FindFirstFile(fullPath, &FindFileData))!=INVALID_HANDLE_VALUE)
		{
         bool bIsFolder = (FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)==FILE_ATTRIBUTE_DIRECTORY;

         bool bAddThisOne = (bIsFolder && bIncludeFoldersInFileList) || ((!bIsFolder) && bIncludeFilesInFileList);

         // skip . and ..
         if (bIsFolder && (strcmp(FindFileData.cFileName, ".")==0) || (strcmp(FindFileData.cFileName, "..")==0))
         {
            bAddThisOne = false;
         }

			if (bAddThisOne) 
         {
				fileName = baseName;
				fileName += FindFileData.cFileName;

				CSAFileEntry t;
				t.m_sName = fileName;

            t.bIsFolder = bIsFolder;
            t.attrib = FindFileData.dwFileAttributes;
			memcpy(&t.time_write, &FindFileData.ftLastWriteTime, sizeof(_FILETIME));
			memcpy(&t.time_create, &FindFileData.ftCreationTime, sizeof(_FILETIME));
            t.size = ((unsigned __int64)FindFileData.nFileSizeHigh * ((unsigned __int64)MAXDWORD+1)) + (unsigned __int64)FindFileData.nFileSizeLow;
				m_files.push_back(t);
			}

			// find the rest of them	
			while (FindNextFile(hFind, &FindFileData))
			{
            bool bIsFolder = (FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)==FILE_ATTRIBUTE_DIRECTORY;

            bool bAddThisOne = (bIsFolder && bIncludeFoldersInFileList) || ((!bIsFolder) && bIncludeFilesInFileList);

            // skip . and ..
            if (bIsFolder && (strcmp(FindFileData.cFileName, ".")==0) || (strcmp(FindFileData.cFileName, "..")==0))
            {
               bAddThisOne = false;
            }

			   if (bAddThisOne) 
			   {
				   fileName = baseName;
				   fileName += FindFileData.cFileName;

				   CSAFileEntry t;
				   t.m_sName = fileName;
               
               t.bIsFolder = bIsFolder;
               t.attrib = FindFileData.dwFileAttributes;
			   memcpy(&t.time_write, &FindFileData.ftLastWriteTime, sizeof(_FILETIME));
			   memcpy(&t.time_create, &FindFileData.ftCreationTime, sizeof(_FILETIME));
               t.size = ((unsigned __int64)FindFileData.nFileSizeHigh * ((unsigned __int64)MAXDWORD+1)) + (unsigned __int64)FindFileData.nFileSizeLow;
				   m_files.push_back(t);
			   }
			}
			FindClose(hFind);
		}
	} 
	catch (...) 
	{
		return false;
	}
#endif

	return true;
}
示例#17
0
// Recursive version of `RemoveDirectory`. NOTE: unlike `rmdir`, this requires
// Windows-formatted paths, and therefore should be in the `internal` namespace.
inline Try<Nothing> recursive_remove_directory(
    const std::string& path, bool removeRoot, bool continueOnError)
{
  // Appending a slash here if the path doesn't already have one simplifies
  // path join logic later, because (unlike Unix) Windows doesn't like double
  // slashes in paths.
  std::string current_path;

  if (!strings::endsWith(path, "\\")) {
    current_path = path + "\\";
  } else {
    current_path = path;
  }

  // Get first file matching pattern `X:\path\to\wherever\*`.
  WIN32_FIND_DATA found;
  const std::string search_pattern = current_path + "*";
  const SharedHandle search_handle(
      FindFirstFile(search_pattern.c_str(), &found),
      FindClose);

  if (search_handle.get() == INVALID_HANDLE_VALUE) {
    return WindowsError(
        "`os::internal::recursive_remove_directory` failed when searching "
        "for files with pattern '" + search_pattern + "'");
  }

  do {
    // NOTE: do-while is appropriate here because folder is guaranteed to have
    // at least a file called `.` (and probably also one called `..`).
    const std::string current_file(found.cFileName);

    const bool is_current_directory = current_file.compare(".") == 0;
    const bool is_parent_directory = current_file.compare("..") == 0;

    // Don't try to delete `.` and `..` files in directory.
    if (is_current_directory || is_parent_directory) {
      continue;
    }

    // Path to remove.
    const std::string current_absolute_path = current_path + current_file;

    const bool is_directory = os::stat::isdir(current_absolute_path);

    // Delete current path, whether it's a directory, file, or symlink.
    if (is_directory) {
      Try<Nothing> removed = recursive_remove_directory(
          current_absolute_path, removeRoot, continueOnError);

      if (removed.isError()) {
        if (continueOnError) {
          LOG(WARNING) << "Failed to delete directory " << current_absolute_path
                       << " with error " << removed.error();
        } else {
          return Error(removed.error());
        }
      }
    } else {
      // NOTE: this also handles symbolic links.
      if (::remove(current_absolute_path.c_str()) != 0) {
        if (continueOnError) {
          LOG(WARNING)
              << "`os::internal::recursive_remove_directory`"
              << " attempted to delete file '"
              << current_absolute_path << "', but failed";
        } else {
          return WindowsError(
              "`os::internal::recursive_remove_directory` attempted to delete "
              "file '" + current_absolute_path + "', but failed");
        }
      }
    }
  } while (FindNextFile(search_handle.get(), &found));

  // Finally, remove current directory unless `removeRoot` is disabled.
  if (removeRoot && ::_rmdir(current_path.c_str()) == -1) {
    if (continueOnError) {
      LOG(WARNING) << "`os::internal::recursive_remove_directory`"
                   << " attempted to delete directory '"
                   << current_path << "', but failed";
      return ErrnoError("rmdir failed in 'continueOnError' mode");
    } else {
      return ErrnoError(
          "`os::internal::recursive_remove_directory` attempted to delete "
          "directory '" + current_path + "', but failed");
    }
  }

  return Nothing();
}
示例#18
0
Application::Application(HINSTANCE _hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    MPQInit();
    instance = this;
    resources = NULL;
    imageLibrary = NULL;
    dotaLibrary = NULL;
    mainWindow = NULL;
    cache = NULL;
    hInstance = _hInstance;
    _loaded = false;

    root = String::getPath(getAppPath());
    cfg.read();

    warLoader = new MPQLoader("Custom_V1");
    warLoader->loadArchive(String::buildFullName(cfg.warPath, "war3.mpq"));
    warLoader->loadArchive(String::buildFullName(cfg.warPath, "war3x.mpq"));
    warLoader->loadArchive(String::buildFullName(cfg.warPath, "war3xlocal.mpq"));
    warLoader->loadArchive(String::buildFullName(cfg.warPath, "war3patch.mpq"));

    if (logCommand(lpCmdLine))
        return;

    ScriptType::initTypes();
    UpdateDialog::init(hInstance);

    INITCOMMONCONTROLSEX iccex;
    iccex.dwSize = sizeof iccex;
    iccex.dwICC = ICC_STANDARD_CLASSES | ICC_PROGRESS_CLASS |
                  ICC_BAR_CLASSES | ICC_TREEVIEW_CLASSES | ICC_LISTVIEW_CLASSES |
                  ICC_TAB_CLASSES | ICC_UPDOWN_CLASS | ICC_DATE_CLASSES;
    InitCommonControlsEx(&iccex);
    LoadLibrary("Riched20.dll");
    OleInitialize(NULL);

    String path = String::getPath(getAppPath());
    String resPath = String::buildFullName(path, "resources.mpq");
    String patchPath = String::buildFullName(path, "install.mpq");
    File* tOpen = File::open(resPath, File::READ);
    if (tOpen == NULL)
    {
        tOpen = File::open(patchPath, File::READ);
        if (tOpen)
        {
            delete tOpen;
            MoveFile(patchPath, resPath);
        }
    }
    else
        delete tOpen;
    resources = MPQArchive::open(resPath);
    MPQArchive* patch = MPQArchive::open(patchPath, File::READ);
    if (patch)
    {
        for (uint32 i = 0; i < patch->getHashSize(); i++)
        {
            char const* name = patch->getFileName(i);
            if (name)
            {
                MPQFile* source = patch->openFile(i, File::READ);
                if (source)
                {
                    MPQFile* dest = resources->openFile(name, File::REWRITE);
                    if (dest)
                    {
                        static uint8 buf[1024];
                        while (int length = source->read(buf, sizeof buf))
                            dest->write(buf, length);
                        delete dest;
                    }
                    delete source;
                }
            }
        }
        delete patch;
        DeleteFile(patchPath);
    }

    imageLibrary = new ImageLibrary(resources);

    cache = new CacheManager();
    dotaLibrary = new DotaLibrary();

#if 0
    File* dlog = File::open("diff.txt", File::REWRITE);
    for (int pt = 0; pt < 120; pt++)
    {
        String prev = "";
        bool different = false;
        for (int ver = 1; ver <= 80 && !different; ver++)
        {
            Dota* dota = dotaLibrary->getDota(makeVersion(6, ver));
            if (dota)
            {
                Dota::Hero* hero = dota->getHero(pt);
                if (hero)
                {
                    if (prev == "")
                        prev = hero->name;
                    else if (prev.icompare(hero->name))
                        different = true;
                }
            }
        }
        if (different)
        {
            dlog->printf("  Pt=%d\r\n", pt);
            prev = "";
            for (int ver = 1; ver <= 80; ver++)
            {
                Dota* dota = dotaLibrary->getDota(makeVersion(6, ver));
                if (dota)
                {
                    Dota::Hero* hero = dota->getHero(pt);
                    if (hero)
                    {
                        if (prev.icompare(hero->name))
                        {
                            dlog->printf("6.%02d = %s\r\n", ver, hero->name);
                            prev = hero->name;
                        }
                    }
                }
            }
        }
    }
    delete dlog;
#endif
#if 0
    dotaLibrary->getDota(parseVersion("6.79e"),
                         "K:\\Progs\\DotAReplay\\maps\\DotA v6.79e.w3x");
    WIN32_FIND_DATA data;
    String enumPath = "K:\\Progs\\DotAReplay\\maps";
    HANDLE hFind = FindFirstFile(String::buildFullName(enumPath, "*"), &data);
    BOOL success = (hFind != INVALID_HANDLE_VALUE);
    while (success)
    {
        String file(data.cFileName);
        if (String::getExtension(file).icompare(".w3x") == 0)
        {
            file.toLower();
            Array<String> sub;
            if (file.rfind("dota{{_| }allstars}?{_| }v(\\d)\\.(\\d\\d)([b-z]?)[^b-z]", 0, &sub) >= 0)
            {
                int major = sub[1].toInt();
                int minor = sub[2].toInt();
                int build = 0;
                if (!sub[3].isEmpty())
                    build = int(sub[3][0] - 'a');
                uint32 version = makeVersion(major, minor, build);

                dotaLibrary->getDota(version, String::buildFullName(enumPath, file));
            }
        }
        success = FindNextFile(hFind, &data);
    }
    FindClose(hFind);
#endif

    mainWindow = new MainWnd();

    mainWindow->postLoad();
    _loaded = true;

    if (lpCmdLine[0])
    {
        COPYDATASTRUCT cd;
        cd.dwData = MAINWND_OPEN_REPLAY;
        cd.cbData = strlen(lpCmdLine) + 1;
        cd.lpData = lpCmdLine;
        PostMessage(getMainWindow(), WM_COPYDATA_FAKE, NULL, (LPARAM) &cd);
    }
}
示例#19
0
void parsedir(char *path)
{
    WIN32_FIND_DATA fd;
    HANDLE handle;
	int curFile = 0, len = 0;
        
    handle = FindFirstFile(path,&fd);
    do 
    {
        if(strcmp(fd.cFileName,".") != 0 && strcmp(fd.cFileName,"..") != 0 && strcmp(fd.cFileName,"list.txt") != 0&& !(fd.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN))
        {
			FILE *infile = NULL;
			char *inpath = (char*)calloc(strlen(path)+strlen(fd.cFileName)+1,sizeof(char));
			unsigned char *buffer = NULL;
			int padding = 0;
			
			if((offset%PADDING)!=0)
			{
				int i = 0, z = 0;
				
				padding = PADDING - (offset%PADDING);
				offset += PADDING - (offset%PADDING);
				//printf("%08x %08x\n",padding,offset);
				
				for(i=0; i<padding; i++)
				{
					fwrite(&z,1,1,outfile);
				}
			}

			strncpy(inpath, path, strlen(path)-1);
			strcat(inpath,fd.cFileName);
			
			infile = fopen(inpath, "rb");
			if(!infile)
			{
				printf("Could not open %s\n",inpath);
				exit(1);
			}
			
			fseek(infile,0,SEEK_END);
			len = ftell(infile);
			rewind(infile);
			
			buffer = (unsigned char*)calloc(len,sizeof(unsigned char));
			fread(buffer,1,len,infile);
			
			if(compressFile != 1)
			{
				unsigned char *lzlrbuff = NULL;
				
				lzlrbuff = CompressLZLR(buffer,len);
				len = lzlroutlen;
				
				fwrite(lzlrbuff,1,len,outfile);
				free(lzlrbuff);
			}
			else
			{
				fwrite(buffer,1,len,outfile);
			}
				
			fclose(outfile);
			outfile = fopen(outname,"rb+");
			fseek(outfile,curFile*8,SEEK_SET);
			fwrite(&offset,1,4,outfile);
			fwrite(&len,1,4,outfile);
			fclose(outfile);
				
			outfile = fopen(outname,"ab+");
			fseek(outfile,0,SEEK_END);
			
			fclose(infile);
			free(buffer);
			
			offset += len;
			curFile++;
			len = 0;
        }
    } while(FindNextFile(handle,&fd) != 0);
	
	fclose(outfile);
	outfile = fopen(outname,"rb+");
	fseek(outfile,curFile*8,SEEK_SET);
	fwrite(&offset,1,4,outfile);
	fwrite(&len,1,4,outfile);
	fclose(outfile);
	outfile = fopen(outname,"ab+");
	fseek(outfile,0,SEEK_END);
}
示例#20
0
bool RecurseDeletePath(const char * a_path)
{
  WIN32_FIND_DATA findData;

  char path[MAX_PATH] = "";
  strcpy(path,a_path);

  // remove trailing '\' char
  int last = (int)strlen(path) - 1;
  if(path[last] == '\\')
  {
    path[last] = '\0';
  }

  // is path valid
  HANDLE h = FindFirstFile(path,&findData);

  // path not could not be found OR path is a file, not a folder
  if((h == INVALID_HANDLE_VALUE) || (!(findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)))
  {
    return false;
  }

  FindClose(h);
  h = NULL;

  // push current working directory
  char currDir[MAX_PATH + 1] = "";
  GetCurrentDirectory(MAX_PATH,currDir);
  SetCurrentDirectory(path);

  // iterate over contents of folder
  h = FindFirstFile("*",&findData);

  if(h != INVALID_HANDLE_VALUE)
  {
    for(;;)
    {
      if(strcmp(findData.cFileName,".") != 0 && strcmp(findData.cFileName,"..") != 0)
      {
        if(findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
        {
          RecurseDeletePath(findData.cFileName);
        }
        else
        {
          DWORD attrs = GetFileAttributes(findData.cFileName);
          if(attrs & FILE_ATTRIBUTE_READONLY)
          {
            SetFileAttributes(findData.cFileName,attrs ^ FILE_ATTRIBUTE_READONLY);
          }
          if(DeleteFile(findData.cFileName) != TRUE)
          {
            DWORD res = GetLastError();
            printf("\nDeleteFile() returned '%d'..\n",(int)res);
          }
        }
      }

      if(!FindNextFile(h,&findData)) break;
    }
  }

  // pop current working directory
  SetCurrentDirectory(currDir);

  FindClose(h);
  h = NULL;

  // remove this directory
  DWORD attrs = GetFileAttributes(path);
  if(attrs & FILE_ATTRIBUTE_READONLY)
  {
    SetFileAttributes(path,attrs ^ FILE_ATTRIBUTE_READONLY);
  }
  return RemoveDirectory(path) != 0;
}
示例#21
0
void ListPatches (HWND hW) {

	int i, tmpi, filesize, totalPatch=0, totalSize=0;
	char tmpStr[MAX_PATH], *fileData;
	WIN32_FIND_DATA FindData;
	HANDLE Find;
	FILE *fp;

	//clear listbox's
	SendDlgItemMessage(hW, IDC_PATCHCRCLIST, (UINT)LB_RESETCONTENT, (WPARAM)NULL, (LPARAM)NULL);
	SendDlgItemMessage(hW, IDC_PATCHNAMELIST, (UINT)LB_RESETCONTENT, (WPARAM)NULL, (LPARAM)NULL);

	//sprintf(tmpStr,"%s*.pnach", Config.PatchDir)
	sprintf(tmpStr, "patches\\*.pnach");

	Find = FindFirstFile(tmpStr, &FindData);

	do {
		if (Find==INVALID_HANDLE_VALUE) break;

		sprintf(tmpStr,"%s", FindData.cFileName);

		//add file name to crc list
		SendDlgItemMessage(hW, IDC_PATCHCRCLIST, (UINT) LB_ADDSTRING, (WPARAM)NULL, (LPARAM)tmpStr);

		//sprintf(tmpStr,"%s%s", Config.PatchDir, FindData.cFileName)
		sprintf(tmpStr,"patches\\%s", FindData.cFileName);

		fp = fopen(tmpStr, "r");
		if (fp == NULL) break;

		fseek(fp, 0, SEEK_END);
		filesize = ftell(fp);
		totalSize += filesize;
		fseek(fp, 0, SEEK_SET);

		fileData = (char *) malloc(filesize+1024);
		sprintf(fileData,"");

		//read file
		while((tmpi=fgetc(fp)) != EOF)
			sprintf(fileData,"%s%c",fileData,tmpi);

		//small hack :p
		for(i=0;i<filesize;i++) {
			if (fileData[i] == 'g' && fileData[i+1] == 'a' &&
				fileData[i+2] == 'm' && fileData[i+3] == 'e' &&
				fileData[i+4] == 't' && fileData[i+5] == 'i' &&
				fileData[i+6] == 't' && fileData[i+7] == 'l' &&
				fileData[i+8] == 'e' && fileData[i+9] == '=')  {

					for(i=i+10,tmpi=0;i<filesize;i++,tmpi++) {
						if (fileData[i] == '\n') break;
						tmpStr[tmpi] = fileData[i];
					}
					tmpStr[tmpi] = '\0';
					break;
				}
		}

		//remove " in the string
		for (i=0,tmpi=0; tmpStr[i]!='\0'; i++)
			if (tmpStr[i] != '"')
				tmpStr[tmpi++] = tmpStr[i];
		tmpStr[tmpi] = '\0';

		//remove spaces at the left of the string
		sprintf(tmpStr,lTrim(tmpStr));

		sprintf(tmpStr,"%s (%s)",tmpStr,FindData.cFileName);

		//add game name to patch name list
		SendDlgItemMessage(hW, IDC_PATCHNAMELIST, (UINT) LB_ADDSTRING, (WPARAM)NULL, (LPARAM)tmpStr);

		totalPatch++;
		sprintf(fileData,"");
		fclose(fp);

	} while (FindNextFile(Find,&FindData));

	if (Find!=INVALID_HANDLE_VALUE) FindClose(Find);

	sprintf(tmpStr,"Patches Browser | Patches Found: %d | Total Filesize: %.2f KB",
		totalPatch,(float)totalSize/1024);
	SetWindowText(hW, tmpStr);
}
int inline CShellBrowser::SetItemInformation(LPITEMIDLIST pidlDirectory,
LPITEMIDLIST pidlRelative,TCHAR *szFileName)
{
	LPITEMIDLIST	pidlItem = NULL;
	HANDLE			hFirstFile;
	TCHAR			szPath[MAX_PATH];
	int				uItemId;

	m_nAwaitingAdd++;

	if((m_nTotalItems + m_nAwaitingAdd) > (m_iCurrentAllocation - 1))
	{
		int PrevSize = m_iCurrentAllocation;

		if(m_iCurrentAllocation > MEM_ALLOCATION_LEVEL_MEDIUM)
			m_iCurrentAllocation += MEM_ALLOCATION_LEVEL_MEDIUM;
		else if(m_iCurrentAllocation > MEM_ALLOCATION_LEVEL_LOW)
			m_iCurrentAllocation += MEM_ALLOCATION_LEVEL_LOW;
		else
			m_iCurrentAllocation += DEFAULT_MEM_ALLOC;

		m_pwfdFiles = (WIN32_FIND_DATA *)realloc(m_pwfdFiles,
			m_iCurrentAllocation * (sizeof(WIN32_FIND_DATA)));

		m_pExtraItemInfo = (CItemObject *)realloc(m_pExtraItemInfo,
			m_iCurrentAllocation * sizeof(CItemObject));

		m_pItemMap = (int *)realloc(m_pItemMap,m_iCurrentAllocation * sizeof(int));

		InitializeItemMap(PrevSize,m_iCurrentAllocation);

		if(m_pwfdFiles == NULL || m_pExtraItemInfo == NULL)
			return E_OUTOFMEMORY;
	}

	uItemId = GenerateUniqueItemId();

	m_pExtraItemInfo[uItemId].pridl					= ILClone(pidlRelative);
	m_pExtraItemInfo[uItemId].bIconRetrieved		= FALSE;
	m_pExtraItemInfo[uItemId].bThumbnailRetreived	= FALSE;
	m_pExtraItemInfo[uItemId].bFolderSizeRetrieved	= FALSE;
	StringCchCopy(m_pExtraItemInfo[uItemId].szDisplayName,MAX_PATH,szFileName);

	pidlItem = ILCombine(pidlDirectory,pidlRelative);

	SHGetPathFromIDList(pidlItem,szPath);

	CoTaskMemFree(pidlItem);

	/* DO NOT call FindFirstFile() on root drives (especially
	floppy drives). Doing so may cause a delay of up to a
	few seconds. */
	if(!PathIsRoot(szPath))
	{
		m_pExtraItemInfo[uItemId].bDrive = FALSE;
		hFirstFile = FindFirstFile(szPath,&m_pwfdFiles[uItemId]);
	}
	else
	{
		m_pExtraItemInfo[uItemId].bDrive = TRUE;
		StringCchCopy(m_pExtraItemInfo[uItemId].szDrive,
			SIZEOF_ARRAY(m_pExtraItemInfo[uItemId].szDrive),
			szPath);

		hFirstFile = INVALID_HANDLE_VALUE;
	}

	/* Need to use this, since may be in a virtual folder
	(such as the recycle bin), but items still exist. */
	if(hFirstFile != INVALID_HANDLE_VALUE)
	{
		m_pExtraItemInfo[uItemId].bReal = TRUE;
		FindClose(hFirstFile);
	}
	else
	{
		StringCchCopy(m_pwfdFiles[uItemId].cFileName,
			sizeof(m_pwfdFiles[uItemId].cFileName)/sizeof(m_pwfdFiles[uItemId].cFileName[0]),szFileName);
		m_pwfdFiles[uItemId].nFileSizeLow			= 0;
		m_pwfdFiles[uItemId].nFileSizeHigh			= 0;
		m_pwfdFiles[uItemId].dwFileAttributes		= FILE_ATTRIBUTE_DIRECTORY;

		m_pExtraItemInfo[uItemId].bReal = FALSE;
	}

	return uItemId;
}
示例#23
0
void 
SPFS::AddFolder(LPCSTR lpszDir,LPCSTR lpszFMask)
{
	if( !IsOpen() )
		throw new SPFSException(_T("pack file isn't opened !"),SPFS_FILE_IS_NOT_OPENED);

	PACK_FSS_HEADER *fss = &_pHeader->fssHeader;
	DWORD  fileCt        = _pHeader->fileCt;               // count of packed files.
	DWORD  written       = 0L;                             // written bytes count.
	DWORD  readSz        = 0L;                             // readed bytes count.
	void*  lpSectionMem  = malloc(_pHeader->fDataSecSz);   // allocate heap memory for file data section.
	DWORD  packOffset    = 0L;                             // offset of pack file handle.
	size_t dirLength     = strlen(lpszDir);                // save directory length size.
	
	// store pointer to the file data section header.
	PACK_FS_HEADER* pFSHeader = (PACK_FS_HEADER*)lpSectionMem;
	// initialize find data structure.
	WIN32_FIND_DATA fData;
	ZeroMemory(&fData,sizeof(WIN32_FIND_DATA));
	sprintf(fData.cFileName,"%s\\%s",lpszDir,lpszFMask);

	char szFilePath[_MAX_PATH];
	sprintf(szFilePath,"%s\\",lpszDir);
	HANDLE hFind        = FindFirstFile(fData.cFileName,&fData);
	HANDLE hFile        = NULL;

	// set file pointer to the end of file data.
	if( hFind == (HANDLE)-1 || SetFilePointer(_hPackFile,0L,0L,FILE_BEGIN) == (DWORD)-1 )
		throw new SPFSException(_T("can't find first SQL file !"),SPFS_FILE_NOT_FOUND);

	while( hFind != (HANDLE)-1 )
		{
		// initialize full path of founded file.
		szFilePath[dirLength+1]     = 0x00;
		strcat(szFilePath,fData.cFileName);

		// open founded file.
		if( m_procOpenFileToAdd )
			hFile = (m_procOpenFileToAdd)(szFilePath);
		else
			hFile = CreateFile(szFilePath,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,0,NULL);

		if( hFile != (HANDLE)-1 )
			{
			// add file into pack file.
			DWORD offset = AddFile(_hPackFile, packOffset, hFile, _pHeader, lpSectionMem, written, m_procPreWriteFileSection);
			// add file into FSS.
			if( offset )	
				AddFileToFSS(fData.cFileName,offset,_pFNArray,_fnArrAlloc,_fnArrUsed,
							 _pFOArray,_foArrAlloc,_pFNOArray,_fnoArrAlloc,fileCt);
			else
				{
				CloseHandle(hFile);
				throw new SPFSException(_T("can't add file to the pack file !"),SPFS_FILE_CANT_WRITE);
				}
			// close file handle.
			CloseHandle(hFile);
			}
		
		// find next file.
		if( !FindNextFile(hFind,&fData) ) 
			{
			// file name offsets array size & file offsets array size.
			UINT arrSize                   = fileCt*sizeof(DWORD);
			// fill pack file header. {{
			_pHeader->fssHeader.start      = 0x68637273;// _T("srch")
			// current offset + file name array size + file offsets array size + name offsets array size.
			_pHeader->packSz               = _pHeader->fssHeader.offsetFSS + _fnArrUsed + 2*arrSize;
            // set FSS section used bytes size.
			_pHeader->fssHeader.secUsedSz  = _fnArrUsed + 2*arrSize;
			// set FSS section full bytes size.
			if( _pHeader->fssHeader.sectionSz < _pHeader->fssHeader.secUsedSz )
				_pHeader->fssHeader.sectionSz = _pHeader->fssHeader.secUsedSz;
			// set file names array size.
			_pHeader->fssHeader.fnArraySz  = _fnArrUsed;
			// set file offsets array size.
			_pHeader->fssHeader.foArraySz  = arrSize;
			// set file name offsets array size.
			_pHeader->fssHeader.fnoArraySz = arrSize;
			// set offset of file names array.
			_pHeader->fssHeader.fnArray    = _pHeader->fssHeader.offsetFSS;
			// set offset of file name offsets array.
			_pHeader->fssHeader.fnoArray   = _pHeader->fssHeader.offsetFSS + _fnArrUsed;
			// set offset of file offsets array.
			_pHeader->fssHeader.foArray    = _pHeader->fssHeader.offsetFSS + _fnArrUsed + arrSize;
			// }}

			//   write pack header.
			if( !WritePackHeader(_hPackFile,_pHeader) )   
				throw new SPFSException(_T("can't write pack file header!"),SPFS_FILE_CANT_WRITE);
			//   write pack FSS.
			if( !WritePackFSS(_hPackFile,_pHeader,_pFNArray,_fnArrUsed,_pFOArray,_pFNOArray,fileCt) )
				throw new SPFSException(_T("can't write FSS(file search section) of pack file !"),SPFS_FILE_CANT_WRITE);
			FindClose(hFind);
			break;
			}
		}
}
示例#24
0
	StringLinkedList getFilesRecursive(AllocatorPool* pool, String directory, Error* error)
	{
		if (directory.length == 0)
		{
			StringLinkedList nullResult = {};
			return nullResult;
		}

		char* lastCharacter = &directory.data[directory.length - 1];
		if (lastCharacter[0] == '/' || lastCharacter[0] == '\\')
		{
			// Trim trailing back-or-forward slash
			directory.length -= 1;
		}

		assert(directory.length < MAX_PATH);

		// Convert String to C-String
		char baseDir[MAX_PATH];
		memcpy(baseDir, directory.data, directory.length);
		baseDir[directory.length] = '\0';

		// Convert C-String to WChar-String
		wchar_t szBaseDir[MAX_PATH];
		mbstowcs(szBaseDir, baseDir, MAX_PATH);

		const u32 directoryLimit = 100;
		wchar_t szDirectories[directoryLimit][MAX_PATH+10];
		u32 directories = 0;
		u32 files = 0;
		StringCchCopy(szDirectories[directories++], MAX_PATH, szBaseDir);

		StringLinkedList list = {};
		while (directories > 0)
		{
			--directories;

			wchar_t currentDirectory[MAX_PATH];
			StringCchCopy(currentDirectory, MAX_PATH, szDirectories[directories]);

			wchar_t currentDirectoryWSearch[MAX_PATH];
			StringCchCopy(currentDirectoryWSearch, MAX_PATH, currentDirectory);
			StringCchCat(currentDirectoryWSearch, MAX_PATH, TEXT("\\*"));

			WIN32_FIND_DATA ffd;
			HANDLE hFind = FindFirstFile(currentDirectoryWSearch, &ffd);
			DWORD dLastError = GetLastError();
			if (hFind == INVALID_HANDLE_VALUE || dLastError == ERROR_FILE_NOT_FOUND) 
			{
				if (error)
				{
					if (dLastError == ERROR_FILE_NOT_FOUND)
					{
						error->errorCode = DIRECTORY_NO_FILES;
					}
					else
					{
						error->errorCode = DIRECTORY_INVALID_DIR;
					}
				}
				StringLinkedList list_null = {};
				return list_null;
			}

			do
			{
				if (wcscmp(ffd.cFileName, TEXT(".")) != 0 && wcscmp(ffd.cFileName, TEXT("..")) != 0)
				{
					if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
					{
						// Push this directory to be searched next iteration.
						StringCchCopy(szDirectories[directories], MAX_PATH, currentDirectory);
						StringCchCat(szDirectories[directories], MAX_PATH, TEXT("\\"));
						StringCchCat(szDirectories[directories], MAX_PATH, ffd.cFileName);
						++directories;
					}
					else
					{
						wchar_t filepath[MAX_PATH];
						StringCchCopy(filepath, ArrayCount(filepath), currentDirectory);
						StringCchCat(filepath, ArrayCount(filepath), TEXT("\\"));
						StringCchCat(filepath, ArrayCount(filepath), ffd.cFileName);
						
						String string = WcharToUTF8String(pool, filepath);
						list.add(string, pool);
						++files;
					}
				}
			}
			while (FindNextFile(hFind, &ffd) != 0);
			FindClose(hFind);
		}
		return list;
	}
示例#25
0
文件: system.c 项目: Einheri/wl500g
/* The idea here is to read all the directory names into a string table
 * (separated by nulls) and when one of the other dir functions is called
 * return the pointer to the current file name.
 */
DIR *
opendir(char *filename)
{
    DIR            *p;
    long            len;
    long            idx;
    char            scannamespc[PATHLEN];
    char       *scanname = scannamespc;
    struct stat     sbuf;
    WIN32_FIND_DATA FindData;
    HANDLE          fh;

    /* check to see if filename is a directory */
    if (stat(filename, &sbuf) < 0 || sbuf.st_mode & S_IFDIR == 0) {
	return NULL;
    }

    /* get the file system characteristics */
/*  if(GetFullPathName(filename, MAX_PATH, root, &dummy)) {
 *	if(dummy = strchr(root, '\\'))
 *	    *++dummy = '\0';
 *	if(GetVolumeInformation(root, volname, MAX_PATH, &serial,
 *				&maxname, &flags, 0, 0)) {
 *	    downcase = !(flags & FS_CASE_IS_PRESERVED);
 *	}
 *  }
 *  else {
 *	downcase = TRUE;
 *  }
 */

    /* Create the search pattern */
    strcpy(scanname, filename);

    if(index("/\\", *(scanname + strlen(scanname) - 1)) == NULL)
	strcat(scanname, "/*");
    else
	strcat(scanname, "*");

    /* do the FindFirstFile call */
    fh = FindFirstFile(scanname, &FindData);
    if(fh == INVALID_HANDLE_VALUE) {
	return NULL;
    }

    /* Get us a DIR structure */
    p = (DIR*)malloc(sizeof(DIR));
    /* Newz(1303, p, 1, DIR); */
    if(p == NULL)
	return NULL;

    /* now allocate the first part of the string table for
     * the filenames that we find.
     */
    idx = strlen(FindData.cFileName)+1;
    p->start = (char*)malloc(idx * sizeof(char));
    /* New(1304, p->start, idx, char);*/
    if(p->start == NULL) {
		free(p);
		return NULL;
    }
    strcpy(p->start, FindData.cFileName);
/*  if(downcase)
 *	strlwr(p->start);
 */
    p->nfiles++;

    /* loop finding all the files that match the wildcard
     * (which should be all of them in this directory!).
     * the variable idx should point one past the null terminator
     * of the previous string found.
     */
    while (FindNextFile(fh, &FindData)) {
	len = strlen(FindData.cFileName);
	/* bump the string table size by enough for the
	 * new name and it's null terminator
	 */
	p->start = (char*)realloc((void*)p->start,
			idx+len+1 * sizeof(char));
	/* Renew(p->start, idx+len+1, char);*/
	if(p->start == NULL) {
		free(p);
	    return NULL;
	}
	strcpy(&p->start[idx], FindData.cFileName);
/*	if (downcase) 
 *	    strlwr(&p->start[idx]);
 */
		p->nfiles++;
		idx += len+1;
	}
	FindClose(fh);
	p->size = idx;
	p->curr = p->start;
	return p;
}
示例#26
0
/*
 * returns 1 if at least one match, else returns 0
 */
BOOL ShowCompletionMatches (LPTSTR str, INT charcount)
{
    WIN32_FIND_DATA file;
    HANDLE hFile;
    BOOL  found_dot = FALSE;
    INT   curplace = 0;
    INT   start;
    INT   count;
    TCHAR path[MAX_PATH];
    TCHAR fname[MAX_PATH];
    TCHAR directory[MAX_PATH];
    SHORT screenwidth;

    /* expand current file name */
    count = charcount - 1;
    if (count < 0)
        count = 0;

    /* find front of word */
    if (str[count] == _T('"'))
    {
        count--;
        while (count > 0 && str[count] != _T('"'))
            count--;
    }
    else
    {
        while (count > 0 && str[count] != _T(' '))
            count--;
    }

    /* if not at beginning, go forward 1 */
    if (str[count] == _T(' '))
        count++;

    start = count;

    if (str[count] == _T('"'))
        count++;    /* don't increment start */

    /* extract directory from word */
    _tcscpy (directory, &str[count]);
    curplace = _tcslen (directory) - 1;

    if (curplace >= 0 && directory[curplace] == _T('"'))
        directory[curplace--] = _T('\0');

    _tcscpy (path, directory);

    while (curplace >= 0 &&
           directory[curplace] != _T('\\') &&
           directory[curplace] != _T(':'))
    {
        directory[curplace] = 0;
        curplace--;
    }

    /* look for a . in the filename */
    for (count = _tcslen (directory); path[count] != _T('\0'); count++)
    {
        if (path[count] == _T('.'))
        {
            found_dot = TRUE;
            break;
        }
    }

    if (found_dot)
        _tcscat (path, _T("*"));
    else
        _tcscat (path, _T("*.*"));

    /* current fname */
    curplace = 0;

    hFile = FindFirstFile (path, &file);
    if (hFile != INVALID_HANDLE_VALUE)
    {
        UINT longestfname = 0;
        /* Get the size of longest filename first. */
        do
        {
            if (_tcslen(file.cFileName) > longestfname)
            {
                longestfname = _tcslen(file.cFileName);
                /* Directories get extra brackets around them. */
                if (file.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
                    longestfname += 2;
            }
        }
        while (FindNextFile (hFile, &file));
        FindClose (hFile);

        hFile = FindFirstFile (path, &file);

        /* Count the highest number of columns */
        GetScreenSize(&screenwidth, 0);

        /* For counting columns of output */
        count = 0;

        /* Increase by the number of spaces behind file name */
        longestfname += 3;

        /* find anything */
        ConOutChar(_T('\n'));
        do
        {
            /* ignore . and .. */
            if (!_tcscmp (file.cFileName, _T(".")) ||
                !_tcscmp (file.cFileName, _T("..")))
                continue;

            if (file.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
                _stprintf (fname, _T("[%s]"), file.cFileName);
            else
                _tcscpy (fname, file.cFileName);

            ConOutPrintf (_T("%*s"), - longestfname, fname);
            count++;
            /* output as much columns as fits on the screen */
            if (count >= (screenwidth / longestfname))
            {
                /* print the new line only if we aren't on the
                 * last column, in this case it wraps anyway */
                if (count * longestfname != (UINT)screenwidth)
                    ConOutChar(_T('\n'));
                count = 0;
            }
        }
        while (FindNextFile (hFile, &file));

        FindClose (hFile);

        if (count)
            ConOutChar(_T('\n'));
    }
    else
    {
        /* no match found */
        MessageBeep (-1);
        return FALSE;
    }

    return TRUE;
}
示例#27
0
文件: os_dirpath.c 项目: aosm/openmpi
/** 
 * This function attempts to remove a directory along with all the
 * files in it.  If the recursive variable is non-zero, then it will
 * try to recursively remove all directories.  If provided, the
 * callback function is executed prior to the directory or file being
 * removed.  If the callback returns non-zero, then no removal is
 * done.  
 */
int opal_os_dirpath_destroy(const char *path,
                            bool recursive,
                            opal_os_dirpath_destroy_callback_fn_t cbfunc)
{
    int rc, exit_status = OPAL_SUCCESS;
    bool is_dir = false;

#ifndef __WINDOWS__
    DIR *dp;
    struct dirent *ep;
    char *filenm;
#ifndef HAVE_STRUCT_DIRENT_D_TYPE 
    struct stat buf;
#endif

    if (NULL == path) {  /* protect against error */
        return OPAL_ERROR;
    }

    /*
     * Make sure we have access to the the base directory
     */
    if( OPAL_SUCCESS != (rc = opal_os_dirpath_access(path, 0) ) ) {
        exit_status = rc;
        goto cleanup;
    }

    /*
     * Open up the directory
     */
    dp = opendir(path);
    if (NULL == dp) {
        return OPAL_ERROR;
    }

    while (NULL != (ep = readdir(dp)) ) {
        /* skip:
         *  - . and ..
         */
        if ((0 == strcmp(ep->d_name, ".")) ||
            (0 == strcmp(ep->d_name, "..")) ) {
            continue;
        }
        
        /* Check to see if it is a directory */
        is_dir = false;

	/* Create a pathname.  This is not always needed, but it makes
	 * for cleaner code just to create it here.  Note that we are
	 * allocating memory here, so we need to free it later on. 
	 */
        filenm = opal_os_path(false, path, ep->d_name, NULL);
#ifdef HAVE_STRUCT_DIRENT_D_TYPE
        if (DT_DIR == ep->d_type) {
            is_dir = true;
        }
#else /* have dirent.d_type */
        rc = stat(filenm, &buf);
        if (rc < 0 || S_ISDIR(buf.st_mode)) {
            is_dir = true;
        }
#endif /* have dirent.d_type */        

        /*
         * If not recursively decending, then if we find a directory then fail
         * since we were not told to remove it.
         */
        if( is_dir && !recursive) {
            /* Set the error indicating that we found a directory,
             * but continue removing files
             */
            exit_status = OPAL_ERROR;
            free(filenm);
            continue;
        }

        /* Will the caller allow us to remove this file/directory? */
        if(NULL != cbfunc) {
            /*
             * Caller does not wish to remove this file/directory,
             * continue with the rest of the entries
             */
            if( ! (cbfunc(path, ep->d_name)) ) {
                free(filenm);
                continue;
            }
        }
        /* Directories are recursively destroyed */
        if(is_dir) {
            rc = opal_os_dirpath_destroy(filenm, recursive, cbfunc);
            free(filenm);
            if (OPAL_SUCCESS != rc) {
                exit_status = rc;
                goto cleanup;
            }
        }
        /* Files are removed right here */
        else {
            if( 0 != (rc = unlink(filenm) ) ) {
                exit_status = OPAL_ERROR;
            }
            free(filenm);
        }
    }
    
    /*
     * Done with this directory
     */
    closedir(dp);
#else
    char search_path[MAX_PATH];
    HANDLE file;
    WIN32_FIND_DATA file_data;
    TCHAR *file_name;
    
    if (NULL == path) {
        return OPAL_ERROR;
    }
    
    strncpy(search_path, path, strlen(path)+1);
    strncat (search_path, OPAL_PATH_SEP"*", 3);
    file = FindFirstFile(search_path, &file_data);
    
    if (INVALID_HANDLE_VALUE == file) {
        FindClose(file);
        return OPAL_ERROR;
    } 
    
    do {
        /*
         * Skip
         * - . and ..
         */
        if ((0 == strcmp(file_data.cFileName, ".")) ||
            (0 == strcmp(file_data.cFileName, "..")) ) {
            continue;
        }
        
        is_dir = false;
        if(file_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
            is_dir = true;
        } 
        /*
         * If not recursively decending, then if we find a directory then fail
         * since we were not told to remove it.
         */
        if( is_dir && !recursive) {
            /* Set the error indicating that we found a directory,
             * but continue removing files
             */
            exit_status = OPAL_ERROR;
            continue;
        }
        
        /* Will the caller allow us to remove this file/directory */
        if( NULL != cbfunc) {
            if( !cbfunc(path, file_data.cFileName) ) {
                continue;
            }
        }

        file_name = opal_os_path(false, path, file_data.cFileName, NULL);
        if( is_dir ) {
            if( OPAL_SUCCESS != (rc = opal_os_dirpath_destroy(file_name,
                                                              recursive,
                                                              cbfunc) ) ) {
                exit_status = rc;
                goto cleanup;
            }
        }
        else {
            DeleteFile(file_name);
        }
    } while( 0 != FindNextFile(file, &file_data) );
    
    FindClose(file);
#endif
    
 cleanup:
    
    /*
     * If the directory is empty, them remove it
     */
    if(opal_os_dirpath_is_empty(path)) {
        rmdir(path);
    }

    return exit_status;
}
示例#28
0
VOID CompleteFilename (LPTSTR str, UINT charcount)
{
    WIN32_FIND_DATA file;
    HANDLE hFile;
    INT   curplace = 0;
    INT   start;
    INT   count;
    INT step;
    INT c = 0;
    BOOL  found_dot = FALSE;
    BOOL  perfectmatch = TRUE;
    TCHAR path[MAX_PATH];
    TCHAR fname[MAX_PATH];
    TCHAR maxmatch[MAX_PATH] = _T("");
    TCHAR directory[MAX_PATH];
    LPCOMMAND cmds_ptr;

    /* expand current file name */
    count = charcount - 1;
    if (count < 0)
        count = 0;

    /* find how many '"'s there is typed already. */
    step = count;
    while (step > 0)
    {
        if (str[step] == _T('"'))
            c++;
        step--;
    }
    /* if c is odd, then user typed " before name, else not. */

    /* find front of word */
    if (str[count] == _T('"') || (c % 2))
    {
        count--;
        while (count > 0 && str[count] != _T('"'))
            count--;
    }
    else
    {
        while (count > 0 && str[count] != _T(' '))
            count--;
    }

    /* if not at beginning, go forward 1 */
    if (str[count] == _T(' '))
        count++;

    start = count;

    if (str[count] == _T('"'))
        count++;	/* don't increment start */

    /* extract directory from word */
    _tcscpy (directory, &str[count]);
    curplace = _tcslen (directory) - 1;

    if (curplace >= 0 && directory[curplace] == _T('"'))
        directory[curplace--] = _T('\0');

    _tcscpy (path, directory);

    while (curplace >= 0 && directory[curplace] != _T('\\') &&
                   directory[curplace] != _T('/') &&
           directory[curplace] != _T(':'))
    {
        directory[curplace] = 0;
        curplace--;
    }

    /* look for a '.' in the filename */
    for (count = _tcslen (directory); path[count] != _T('\0'); count++)
    {
        if (path[count] == _T('.'))
        {
            found_dot = TRUE;
            break;
        }
    }

    if (found_dot)
        _tcscat (path, _T("*"));
    else
        _tcscat (path, _T("*.*"));

    /* current fname */
    curplace = 0;

    hFile = FindFirstFile (path, &file);
    if (hFile != INVALID_HANDLE_VALUE)
    {
        /* find anything */
        do
        {
            /* ignore "." and ".." */
            if (!_tcscmp (file.cFileName, _T(".")) ||
                !_tcscmp (file.cFileName, _T("..")))
                continue;

            _tcscpy (fname, file.cFileName);

            if (file.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
                _tcscat (fname, _T("\\"));

            if (!maxmatch[0] && perfectmatch)
            {
                _tcscpy(maxmatch, fname);
            }
            else
            {
                for (count = 0; maxmatch[count] && fname[count]; count++)
                {
                    if (tolower(maxmatch[count]) != tolower(fname[count]))
                    {
                        perfectmatch = FALSE;
                        maxmatch[count] = 0;
                        break;
                    }
                }

                if (maxmatch[count] == _T('\0') &&
                    fname[count] != _T('\0'))
                    perfectmatch = FALSE;
            }
        }
        while (FindNextFile (hFile, &file));

        FindClose (hFile);

        /* only quote if the filename contains spaces */
        if (_tcschr(directory, _T(' ')) ||
            _tcschr(maxmatch, _T(' ')))
        {
            str[start] = _T('\"');
            _tcscpy (&str[start+1], directory);
            _tcscat (&str[start], maxmatch);
            _tcscat (&str[start], _T("\"") );
        }
        else
        {
            _tcscpy (&str[start], directory);
            _tcscat (&str[start], maxmatch);
        }

        if (!perfectmatch)
        {
            MessageBeep (-1);
        }
    }
    else
    {
        /* no match found - search for internal command */
        for (cmds_ptr = cmds; cmds_ptr->name; cmds_ptr++)
        {
            if (!_tcsnicmp (&str[start], cmds_ptr->name,
                _tcslen (&str[start])))
            {
                /* return the mach only if it is unique */
                if (_tcsnicmp (&str[start], (cmds_ptr+1)->name, _tcslen (&str[start])))
                    _tcscpy (&str[start], cmds_ptr->name);
                break;
            }
        }

        MessageBeep (-1);
    }
}
示例#29
0
// Loads lua scripts from given directory
void Eluna::LoadDirectory(char* Dirname, LoadedScripts* lscr)
{
#ifdef WIN32
    HANDLE hFile;
    WIN32_FIND_DATA FindData;
    memset(&FindData, 0, sizeof(FindData));
    char SearchName[MAX_PATH];

    strcpy(SearchName, Dirname);
    strcat(SearchName, "\\*.*");

    hFile = FindFirstFile(SearchName, &FindData);
    if (hFile == INVALID_HANDLE_VALUE)
    {
        sLog.outErrorEluna("[Eluna]: Error No `lua_scripts` directory found! Creating a 'lua_scripts' directory.");
        CreateDirectory("lua_scripts", NULL);
        return;
    }

    FindNextFile(hFile, &FindData);
    while (FindNextFile(hFile, &FindData))
    {
        if (FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
        {
            strcpy(SearchName, Dirname);
            strcat(SearchName, "\\");
            strcat(SearchName, FindData.cFileName);
            LoadDirectory(SearchName, lscr);
        }
        else
        {
            std::string fname = Dirname;
            fname += "\\";
            fname += FindData.cFileName;
            size_t len = strlen(fname.c_str());
            int i = 0;
            char ext[MAX_PATH];
            while (len > 0)
            {
                ext[i++] = fname[--len];
                if (fname[len] == '.')
                    break;
            }
            ext[i++] = '\0';
            if (!_stricmp(ext, "aul."))
            {
                sLog.outDebug("[Eluna]: Load File: %s", fname.c_str());
                lscr->insert(fname);
            }
        }
    }
    FindClose(hFile);
#else
    char* dir = strrchr(Dirname, '/');
    if (strcmp(Dirname, "..") == 0 || strcmp(Dirname, ".") == 0)
        return;

    if (dir && (strcmp(dir, "/..") == 0 || strcmp(dir, "/.") == 0 || strcmp(dir, "/.svn") == 0))
        return;

    struct dirent** list;
    int fileCount = scandir(Dirname, &list, 0, 0);

    if (fileCount <= 0 || !list)
        return;

    struct stat attributes;
    bool error;
    while (fileCount--)
    {
        char _path[200];
        sprintf(_path, "%s/%s", Dirname, list[fileCount]->d_name);
        if (stat(_path, &attributes) == -1)
        {
            error = true;
            sLog.outErrorEluna("[Eluna]: Error opening `%s`", _path);
        }
        else
            error = false;

        if (!error && S_ISDIR(attributes.st_mode))
            LoadDirectory((char*)_path, lscr);
        else
        {
            char* ext = strrchr(list[fileCount]->d_name, '.');
            if (ext && !strcmp(ext, ".lua"))
                lscr->insert(_path);
        }
        free(list[fileCount]);
    }
    free(list);
#endif
}
示例#30
0
int SSL_CTX_load_verify_locations(SSL_CTX* ctx, const char* file,
                                  const char* path)
{
    int       ret = SSL_FAILURE;
    const int HALF_PATH = 128;

    if (file) ret = read_file(ctx, file, SSL_FILETYPE_PEM, CA);

    if (ret == SSL_SUCCESS && path) {
        // call read_file for each reqular file in path
#ifdef _WIN32

        WIN32_FIND_DATA FindFileData;
        HANDLE hFind;

        char name[MAX_PATH + 1];  // directory specification
        strncpy(name, path, MAX_PATH - 3);
        strncat(name, "\\*", 3);

        hFind = FindFirstFile(name, &FindFileData);
        if (hFind == INVALID_HANDLE_VALUE) return SSL_BAD_PATH;

        do {
            if (FindFileData.dwFileAttributes != FILE_ATTRIBUTE_DIRECTORY) {
                strncpy(name, path, MAX_PATH - 2 - HALF_PATH);
                strncat(name, "\\", 2);
                strncat(name, FindFileData.cFileName, HALF_PATH);
                ret = read_file(ctx, name, SSL_FILETYPE_PEM, CA);
            }
        } while (ret == SSL_SUCCESS && FindNextFile(hFind, &FindFileData));

        FindClose(hFind);

#else   // _WIN32

        const int MAX_PATH = 260;

        DIR* dir = opendir(path);
        if (!dir) return SSL_BAD_PATH;

        struct dirent* entry;
        struct stat    buf;
        char           name[MAX_PATH + 1];

        while (ret == SSL_SUCCESS && (entry = readdir(dir))) {
            strncpy(name, path, MAX_PATH - 1 - HALF_PATH);
            strncat(name, "/", 1);
            strncat(name, entry->d_name, HALF_PATH);
            if (stat(name, &buf) < 0) return SSL_BAD_STAT;
     
            if (S_ISREG(buf.st_mode))
                ret = read_file(ctx, name, SSL_FILETYPE_PEM, CA);
        }

        closedir(dir);

#endif
    }

    return ret;
}