Module 2 - Politecnico di Torino
Download
Report
Transcript Module 2 - Politecnico di Torino
Input/Output
With File and Directory
Processing
OBJECTIVES
Describe the Windows file systems (compared to UNIX/Linux)
Perform sequential file processing
Perform console I/O and direct access file I/O
Report and analyze system call errors
Describe and use Unicode characters and strings and write generic
applications (both Unicode and ASCII characters)
Use Windows file locking to protect files from concurrent modification
by several processes
Perform file and directory management
–2–
File Systems and
Sequential I/O
BASIC Windows I/O
Basic Windows API file processing functions:
CreateFile
ReadFile
WriteFile
CloseHandle
Windows files are:
–4–
binary
text (lines are CR-LF terminated)
BASIC UNIX I/O
Basic UNIX file processing functions are eqiovalent:
open
read
write
close
UNIX files are:
–5–
Plain byte streams
text lines are LF terminated
C library I/O
Basic C file processing functions are equivalent:
fopen
fread
fwrite
fclose
–6–
THE FILE SYSTEMS
Windows File Systems
(Virtual) File Allocation Table File System (FAT, VFAT)
The only disk file system for floppies and Windows 9x
NTFS File System (NTFS)
Very large (“huge”) files, secure, robust
Supported on Windows NT (all versions)
CD-ROM File System (CDFS)
Custom file systems
Developed by software vendors
–7–
Windows FILE NAMING (1/2)
Hierarchical
Full pathname can start with a drive name
A:, C:, …
Or with a “share” name
\\servername\sharename
Pathname separator is a backslash — \
You can also use / in C
Directory and file names cannot use ASCII 1–31
Or any of < > : " |
But you can have blanks in file names
Case insensitive but case retaining
–8–
Windows FILE NAMING (2/2)
File, directory names up to 255 characters long
250 in Windows 9x
More with UNICODE
A period . separates a file’s name from its extension
The period is in the name; there can be more than one
. and .. indicate the current directory and its parent
No file link (as in UNIX)
Alternate data stream
–9–
Different logical files for the same phisical file
A problem for security !!!
UNIX file systems
Ext2 and Ext3 (Linux)
JFS (AIX)
XFS (IRIX)
Names are case-sensitive
Max. name length implementation dependent
Links used (hard and symbolic)
– 10 –
CREATING AND OPENING FILES
Windows
HANDLE CreateFile (LPCTSTR lpName,
DWORD dwAccess, DWORD dwShareMode,
LPSECURITY_ATTRIBUTES lpsa, DWORD dwCreate,
DWORD dwAttrsAndFlags, HANDLE hTemplateFile)
Return: A HANDLE to an open file object
INVALID_HANDLE_VALUE in case of failure
LPCTSTR will be described in Part II
– 11 –
CREATING AND OPENING (2/6)
Parameters
lpName
Pointer to the string naming the file
Length normally limited to 260
\\?\ is an escape prefix allowing long NT path names
dwAccess
– 12 –
Access using GENERIC_READ or GENERIC_WRITE
Note: Flags can be combined with |
CREATING AND OPENING (3/6)
dwShareMode
0 — Cannot be shared; not even this process can open another
handle
FILE_SHARE_READ — Other processes can read concurrently
FILE_SHARE_WRITE — Other processes can write concurrently
lpsa points to a SECURITY_ATTRIBUTES structure
– 13 –
NULL for now
CREATING AND OPENING (4/6)
dwCreate — Create a file, overwrite one, etc.
CREATE_NEW — Fails if the file exists
CREATE_ALWAYS — An existing file will be overwritten
OPEN_EXISTING — Fail if the file does not exist
OPEN_ALWAYS — Open the file or create it if it doesn’t exist
TRUNCATE_EXISTING — File length will be set to zero
Note: There is no “open to append” mode
– 14 –
You will need to position to the end of file
CREATING AND OPENING (5/6)
dwAttrsAndFlags — 16 flags and attributes including:
FILE_ATTRIBUTE_NORMAL — No other attributes are set
FILE_ATTRIBUTE_READONLY — Cannot write or delete
FILE_FLAG_OVERLAPPED
FILE_FLAG_SEQUENTIAL_SCAN and
FILE_FLAG_RANDOM_ACCESS provide performance hints
Attributes are properties of the files themselves
Flags are associated with a specific HANDLE
Different HANDLEs to the same file can have different flags
Example: One HANDLE is “overlapped,” another not
Or, one has FILE_FLAG_SEQUENTIAL_SCAN and another
FILE_FLAG_RANDOM_ACCESS
– 15 –
CREATING AND OPENING (6/6)
File processing flags include:
FILE_FLAG_WRITE_THROUGH
FILE_FLAG_NO_BUFFERING
FILE_FLAG_DELETE_ON_CLOSE
hTemplateFile — Handle of an open GENERIC_READ file
– 16 –
Use the same attributes for the new file
READING FILES (1/2)
BOOL ReadFile (HANDLE hFile, LPVOID lpBuffer,
DWORD nNumberOfBytesToRead,
LPDWORD lpNumberOfBytesRead,
LPOVERLAPPED lpOverlapped)
Return: TRUE if the read succeeds
– 17 –
Even if no bytes were read due to an attempt to read past the
end of file
FALSE indicates an invalid handle, a handle without
GENERIC_READ access, etc.
READING FILES (2/2)
Parameters
hFile — File handle with GENERIC_READ access
lpBuffer — Memory buffer to receive the input data
nNumberOfBytesToRead
Number of bytes you expect to read
*lpNumberOfBytesRead
Actual number of bytes transferred
Zero indicates end of file
lpOverlapped
– 18 –
Points to OVERLAPPED structure (NULL for now)
WRITING FILES
BOOL WriteFile (
HANDLE hFile, CONST VOID *lpBuffer,
DWORD nNumberOfBytesToWrite,
LPDWORD lpNumberOfBytesWritten,
LPOVERLAPPED lpOverlapped)
Return: TRUE if the function succeeds; FALSE otherwise
– 19 –
CLOSING FILES
BOOL CloseHandle (HANDLE hObject)
Return: TRUE if the function succeeds; FALSE otherwise
This function is general purpose and will be used to close
handles to many different object types
– 20 –
COPYING FILES
BOOL CopyFile (LPCTSTR lpExistingFile,
LPCTSTR lpNewFile, BOOL fFailIfExists)
If a file with the new name already exists, it will be
replaced only if fFailIfExists is FALSE
This is a “convenience function” and also provides
performance
– 21 –
Equivalent UNIX and Libc functions
UNIX
open, read, write, close
C library
fopen, fread, fwrite, fclose
Data sizes are not specified in terms of bytes, but as
– 22 –
Object size + number of objects
Character and String
Encoding
UNICODE & GENERIC CHARACTERS
Windows NT supports 16-bit characters
WCHAR or wchar_t
To assure maximum flexibility and source portability, define all
characters and strings using “generic” type
TCHAR
Calculate lengths using sizeof(TCHAR)
Include #define UNICODE (to get WCHAR) in all source modules
(or #undef UNICODE to get CHAR)
Be consistent
Define UNICODE before #include <windows.h>
– 24 –
Also define _UNICODE consistently for the generic C library
GENERIC CHARACTERS (2/3)
Use the “generic” C library for all string functions
_tprintf
in place of printf
_stprintf
in place of sprintf
_tcslen
in place of strlen
_itot
in place of itoa
And MANY more
See the on line help and the lab programs
– 25 –
Generic versions of some functions are not provided
e.g. memchr - Replacements are in the lab solutions
GENERIC CHARACTERS (3/3)
Constant strings in one of three forms (first 2 are ANSI C)
The last is a macro
"This string uses 8-bit characters"
L"This string uses 16-bit characters"
_T ("This string uses generic characters")
Expands to “T…” if UNICODE is not defined; L”T…” if it is
TEXT macro is the same as _T
LPTSTR expands to either char * or wchar_t *
– 26 –
THE GENERIC C LIBRARY
Define _UNICODE consistently with UNICODE
This makes available a wide class of string processing and I/O
functions
_fgettc, _itot, _ttoi, _totupper, _totlower
And many more — nearly the complete library
Also, locale-specific functions (seven in all):
lstrlen, lstrcmp, lstrcpy, lstrcat, …
Be sure to #include <tchar.h> after <windows.h>
Note: Any _ keyword or function is specific to Microsoft
Visual C++ and the Microsoft compiler
– 27 –
GENERIC CHARACTERS AND THE
MAIN PROGRAM
Windows main is for ASCII; wmain is for Unicode
In place of int main (argc, char * argv[])
or int main (argc, w_char * argv[])
Use #include <tchar.h>
/* this is after <windows.h> */
... int _tmain (int argc, LPTSTR argv[])
The _tmain macro then expands to main or wmain
Depending on definition of _UNICODE
This assures correct operation in all circumstances and
combinations
– 28 –
Standard Devices
STANDARD DEVICES
AND CONSOLE I/O (1/4)
Both UNIX and Win32 have 3 “standard” devices for input,
output and error.
Unix uses first 3 file descriptors (0, 1, 2)
Win32 requires handle and provides a function to get
standard device handlers from integer constants
HANDLE GetStdHandle(DWORD nStdHandle)
Return: A valid handle or INVALID_HANDLE_VALUE for
failure
In order to redirect a standard device, use
BOOL SetStdHandle(DWORD nStdHandle, HANDLE hHandle)
Return: TRUE or FALSE indicating success or failure
– 30 –
STANDARD DEVICES
AND CONSOLE I/O (2/4)
nStdHandle must have one of these values:
STD_INPUT_HANDLE
STD_OUTPUT_HANDLE
STD_ERROR_HANDLE
hHandle
Specifies an open file that is to be the standard device
Two reserved pathnames for console
– 31 –
input (the keyboard): "CONIN$"
output (the display): "CONOUT$"
STANDARD DEVICES
AND CONSOLE I/O (3/4)
BOOL SetConsoleMode (HANDLE hConsole,
DWORD fdevMode)
Return: TRUE if and only if the function succeeds
hConsole must have GENERIC_WRITE access
fDevMode: How characters are processed
ENABLE_WINDOW_INPUT
ENABLE_LINE_INPUT
ENABLE_ECHO_INPUT
...
Equivalent UNIX function:
#include <termios.h>
int tcsetattr (int fd, int optional_actions, struct termios *termios_p);
– 32 –
STANDARD DEVICES
AND CONSOLE I/O (4/4)
BOOL ReadConsole (HANDLE hConsoleInput,
LPVOID lpvBuffer, DWORD cchToRead,
LPDWORD lpcchRead, LPVOID lpvReserved)
Return: TRUE if and only if the read succeeds
lpvReserved must be NULL
BOOL WriteConsole
Same as ReadConsole
Other functions:
BOOL FreeConsole (VOID)
BOOL AllocConsole (VOID)
(GUI) Applications with no default console need
AllocConsole before WriteConsole or printf
– 33 –
EXAMPLE: PrintStrings (1/3)
#include "envirmnt.h" /* UNICODE is defined here */
#include <windows.h>
BOOL PrintStrings (HANDLE hOut, ...)
/* Write the messages to the output handle (hOut)
Use WriteConsole (to handle Unicode & console
processing) first, as the output will normally
be the console. If that fails, use WriteFile.
hOut: Handle for output file.
... : Variable argument list containing TCHAR
strings. The list must be terminated with NULL. */
– 34 –
PrintStrings (2/3)
{
DWORD MsgLen, Count;
BOOL Success = TRUE;
LPCTSTR pMsg;
va_list pMsgList;
/* Current message string */
va_start (pMsgList, hOut);
/* Start processing msgs */
while (((pMsg = va_arg (pMsgList, LPCTSTR)) != NULL)
&& Success)
{
MsgLen = _tcslen (pMsg);
(CONTINUED)
– 35 –
PrintStrings (3/3)
/* WriteConsole fails if the handle is associated
with a file rather than with a console */
if (!WriteConsole (hOut, pMsg,
MsgLen, &Count, NULL)
&&
!WriteFile (hOut, pMsg,
MsgLen * sizeof (TCHAR), &Count, NULL))
return FALSE;
} /* End of while loop - process next message */
va_end (pMsgList);
return TRUE;
}
– 36 –
EXAMPLE: ReportError (1/4)
OBJECTIVE:
Turn system call errors into meaningful text strings
And print the text
Terminate the program if the error is fatal
Similar to perror(), but it works in the multithreaded
Windows environment.
– 37 –
EXAMPLE: ReportError (2/4)
#include "envirmnt.h"
#include <windows.h>
#include "support.h"
VOID ReportError (LPCTSTR UserMessage,
DWORD ExitCode, BOOL PrintErrorMsg)
/* General-purpose function to report system errors.
Obtain the error number and turn it into the
system error message. Display this information
and the user specified message to the standard
error device.
UserMessage: Message to be displayed to
standard error device.
*/
– 38 –
ReportError (3/4)
ExitCode:
0 - Return
> 0 - ExitProcess with this code
PrintErrorMessage: Display the last system error
message if this flag is set. */
{
DWORD eMsgLen, ErrNum = GetLastError ();
LPVOID lpvSysMsg;
HANDLE hStdErr = GetStdHandle (STD_ERROR_HANDLE);
PrintMsg (hStdErr, UserMessage);
if (PrintErrorMsg) {
– 39 –
ReportError (4/4)
eMsgLen = FormatMessage (
FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM,
NULL, ErrNum,
MAKELANGID (LANG_DFLT, SUBLANG_DFLT),
&lpvSysMsg, 0, NULL);
PrintStrings (hStdErr, TEXT ("\n"),
lpvSysMsg, TEXT ("\n"), NULL);
HeapFree (GetProcessHeap (), 0, lpvSysMsg);
}
if (ExitCode > 0)
ExitProcess (ExitCode);
else
return;
}
– 40 –
File Pointers
32 bits vs 64 bits
Win32 can handle 64 bit addresses, even though it is a 32
bit OS
Most Unix systems have “large files“ support
(64 bit file addresses) and some systems are 64 bit OS.
Linux, based on 32 bit Intel platforms, is mainly a 32 bit
system.
– 42 –
Supports large files (> 2 GB) by means of the Large File Interface
(available since kernel 2.4)
FILE POINTERS (1/4)
Most operating systems (and C library) support pointers
to open files, to refer actual locations within files
Read and write operations start from the file location referred to
by a file pointer, and increment the pointer
A file pointer can be modified by
C library:
» int fsetpos( FILE *stream, fpos t *pos)
» int fseek( FILE *stream, long offset, int whence)
Linux/Unix:
» off_t lseek(int fildes, off_t offset, int whence)
whence is the reference point from which to evaluate a displacement
(allowed values: SEEK_SET, SEEK_CUR, SEEK_END)
lseek returns current position, ftell(FILE *stream) in C library
– 43 –
FILE POINTERS – WIN32 (1/4)
DWORD SetFilePointer (HANDLE hFile,
LONG lDistanceToMove,
PLONG lpDistanceToMoveHigh,
DWORD dwMoveMethod)
Return: The low-order DWORD (unsigned) of the new file
pointer. The high-order portion of the new file pointer
goes to the DWORD indicated by lpDistanceToMoveHigh
(if non-NULL). In case of error, the return value is
OxFFFFFFFF.
Note: The file pointer is associated with the HANDLE, not
the file. The pointer advances with each read and write.
– 44 –
FILE POINTERS – WIN32 (2/4)
Note: NTFS is a 64-bit file system, so file pointers are 64
bits long. The file pointer is specified with two 32-bit
parts.
Large files are increasingly important in many applications
But many users will only require “short” (< 4GB) files
SetFilePointer Parameters
hFile — Handle of an open file with read and/or write
access
lDistanceToMove — LONG signed distance to move or
unsigned file position
– 45 –
FILE POINTERS – WIN32 (3/4)
*lpDistanceToMoveHigh
High-order portion of the move distance
Can be NULL for “small” files
dwMoveMethod — Specifies one of these modes:
FILE_BEGIN — Position from the start of file
FILE_CURRENT — Move pointer forward or backward
FILE_END — Position backward from end of file
SetEndOfFile () function resizes the file based on the
current file pointer
– 46 –
FILE POINTERS – WIN32 (4/4)
Use the LARGE_INTEGER data type (union) for 64-bit file
positions
Example coming up
Members:
LONGLONG Quadpart
DWORD LowPart
LONG HighPart
– 47 –
Do the 64-bit arithmetic here
Alternative Direct File Access Using
the Overlapped Structure (1/2)
Example: Use the Offset fields in the overlapped structure
Offset
OffsetHigh
hEvent
Two reserved fields
Low order 32 bits
High order 32 bits
Must be NULL. This field is
used with asynchronous I/O
Do not use!!
The example shows how to update a record in a file
– 48 –
Alternative Direct File Access Using
the Overlapped Structure (2/2)
OVERLAPPED ov = { 0, 0, 0, 0, NULL };
RECORD r; /* Includes “reference count” field */
LONGLONG n;
LARGE_INTEGER FilePos;
DWORD nRd, nWrt;
. . .
/* Update reference count in the n’th record. */
FilePos.QuadPart = n * sizeof (RECORD);
ov.Offset = FilePos.LowPart;
ov.OffsetHigh = FilePos.HighPart;
ReadFile (hFile, &r, sizeof(RECORD), &nRd, &ov);
r.RefCount++; /* Update the record. */
WriteFile(hFile, &r, sizeof(RECORD), &nWrt, &ov);
– 49 –
File Locking
WIN32 FILE LOCKING (1/5)
– 51 –
Lock all or part of a file
Lock can be read-only (sharable) or read-write (exclusive)
Lock belongs to a process
Any attempt to access part of a file (using ReadFile or
WriteFile) in violation of a lock will fail
You cannot create conflicting locks on a file
Specify whether you should wait for a lock to become available,
or thread can return immediately, indicating whether it obtained
the lock
WIN32 FILE LOCKING (2/5)
BOOL LockFileEx (HANDLE hFile, DWORD dwFlags,
DWORD dwReserved,
DWORD nNumberOfBytesToLockLow,
DWORD nNumberOfBytesToLockHigh,
LPOVERLAPPED lpOverlapped)
– 52 –
Locks a byte range in an open file for shared (multiple readers)
or exclusive (one reader-writer) access
WIN32 FILE LOCKING (3/5)
Parameters
hFile — Handle of an open file which must have at least one of
GENERIC_READ or GENERIC_WRITE access
dwFlags — Determines the lock mode and whether to wait for
the lock to become available
LOCKFILE_EXCLUSIVE_LOCK, if set, indicates a request for an
exclusive, read-write, lock; otherwise, it requests a shared (read
only) lock
LOCKFILE_FAIL_IMMEDIATELY, if set, specifies that the
function should return immediately with a FALSE if the lock cannot
be acquired; otherwise, the call blocks until the lock becomes
available
– 53 –
WIN32 FILE LOCKING (4/5)
dwReserved must be zero
lpOverlapped — Points to an OVERLAPPED data structure
containing the start of the byte range
The OVERLAPPED structure contains two data members that must
be set (the others are ignored), namely:
DWORD Offset and
DWORD OffsetHigh
A file lock is removed with a corresponding UnlockFileEx
call, using all the same parameters except for dwFlags
– 54 –
WIN32 FILE LOCKING (5/5)
BOOL UnlockFileEx (HANDLE hFile,
DWORD dwReserved,
DWORD nNumberOfBytesToLockLow,
DWORD nNumberOfBytesToLockHigh,
LPOVERLAPPED lpOverlapped)
– 55 –
FILE LOCKING IN WINDOWS 9x
Exclusive locks only
BOOL LockFile (HANDLE hFile,
DWORD dwOffsetLow, DWORD dwOffsetHigh
DWORD nNumberOfBytesToLockLow,
DWORD nNumberOfBytesToLockHigh)
BOOL UnlockFile (HANDLE hFile,
DWORD dwOffsetLow, DWORD dwOffsetHigh
DWORD nNumberOfBytesToLockLow,
DWORD nNumberOfBytesToLockHigh)
– 56 –
WIN32 FILE LOCKING CONSIDERATIONS
– 57 –
The unlock must use exactly the same range as a preceding
lock
Locks cannot overlap existing locked regions in a file
You can lock beyond the range of a file’s length
Locks are not inherited by a newly created process
LOCK REQUEST LOGIC
Requested Lock Type
Existing Lock
Shared Lock
Exclusive Lock
None
Granted
Granted
Shared Lock
(one or more)
Granted
Refused
Exclusive Lock
Refused
Refused
– 58 –
LOCKS AND I/O OPERATION
I/O Operation
Existing Lock
Read
Write
None
Succeeds
Succeeds
Shared Lock
(one or more)
Succeeds. It is not
necessary for the calling
process to own a lock
on the file region.
Exclusive Lock
Refused
Succeeds if the calling process owns the
lock. Fails otherwise.
– 59 –
WIN32 FILE LOCKS—SUMMARY (1/2)
– 60 –
A failed read or write may take the form of a partially complete
operation if only a portion of the read or write record is locked
Read and write operations are normally in the form of ReadFile
and WriteFile calls, or ReadFileEx and WriteFileEx
Diagnosing a read or write failure requires calling
GetLastError
Accessing memory that is mapped to a file is another form of
file I/O
WIN32 FILE LOCKS—SUMMARY (2/2)
– 61 –
Lock conflicts are not detected at the time of memory reference;
rather, they are detected at the time MapViewOfFile is called
The LockFile function is a limited, special case which gives
exclusive access and returns immediately
UNIX/Linux file locking (1/2)
“Advisory” and “Mandatory” locks
Always use POSIX.1 function fcntl or its interface
lockf()
int fcntl(int fd, int cmd, struct flock * lock);
struct flock {
short int l_type; /* Type of lock: F_RDLCK,
F_WRLCK, or F_UNLCK */
short int l_whence; /* Where ‘l_start’ is relative
to */
__off_t l_start; /* Offset where the lock begins.
*/
__off_t l_len; /* Size of the locked area; zero
means EOF */
__pid_t l_pid; /* Process holding the lock. */
};
– 62 –
UNIX/Linux file locking (2/2)
3 possible values for cmd: F_GETLK, F_SETLK,
F_SETLKW
3 values for whence: SEEK_SET, SEEK_CUR,
SEEK_END
– 63 –
fcntl is used for 5 purposes
• duplicate an existing descriptor (cmd=F_DUPFD)
• obtain/define close-on-exec flag for a file descriptor
(cmd=F_GETFD or F_SETFD)
• obtain/define file status flag (cmd=F_GETFL or F_SETFL).
Possible flags: O_NONBLOCK, O_APPEND, O_ASYNC.
• obtain/define ownership for asynchronous I/O
(cmd=F_GETOWN or F_SETOWN)
• obtain/define record locks (cmd=F_GETLK, F_SETLK or
F_SETLKW)
– 64 –
File and Directory
Management
FILE AND DIRECTORY
MANAGEMENT
BOOL DeleteFile (LPCTSTR lpFileName)
You cannot delete an open file in Windows NT
(You can in Windows 9x)
– 66 –
FILE AND DIRECTORY
MANAGEMENT—RENAMING (1/2)
BOOL MoveFile (LPCTSTR lpExisting,
LPCTSTR lpNew)
Source and target files must be on the same drive
BOOL MoveFileEx (LPCTSTR lpExisting,
LPCTSTR lpNew, DWORD dwFlags)
Source and target files can be on different drives
Note: There are no links as in UNIX
– 67 –
Neither soft links nor hard links
Shortcuts are not the same thing; they are only recognized by
the visual shell
FILE AND DIRECTORY
MANAGEMENT—RENAMING (2/2)
Parameters
lpExisting — The name of the existing file or directory
lpNew — Cannot exist with MoveFile
Must be on same drive
dwFlags
MOVEFILE_REPLACE_EXISTING
To replace an existing file
MOVEFILE_COPY_ALLOWED
Copy then delete
– 68 –
DIRECTORY MANAGEMENT (1/4)
BOOL CreateDirectory (LPCTSTR lpPath,
LPSECURITY_ATTRIBUTES lpsa)
BOOL RemoveDirectory (LPCTSTR lpPath)
lpPath
– 69 –
Points to a null-terminated string with the directory name
DIRECTORY MANAGEMENT (2/4)
BOOL SetCurrentDirectory (LPCTSTR lpCurDir)
lpCurDir
The path to the new current directory
There is actually a current directory maintained for each
drive
SetCurrentDirectory (TEXT("C:"));
– 70 –
Will set the C: drive directory to its current value
DIRECTORY MANAGEMENT (3/4)
DWORD GetCurrentDirectory (DWORD cchCurDir,
LPTSTR lpCurDir)
Return:
The string length of the returned pathname
The required buffer size if the buffer is not large enough
This includes the space for the null string terminator
– 71 –
Zero if the function fails
DIRECTORY MANAGEMENT (4/4)
Windows uses this technique whenever the result’s length
is not known
Parameters
cchCurDir
Character length of the buffer for the directory name
cch - “Count in characters”
lpCurDir
– 72 –
Points to the buffer to receive the pathname string
TESTING GetCurrentDirectory
FOR CORRECT OPERATION
/* pwd: Print the working directory.
Similar to the UNIX pwd command */
/* This program illustrates:
1. Windows GetCurrentDirectory
2. Testing the length of a returned string */
#include "EvryThng.h"
#define DIRNAME_LEN MAX_PATH + 2
int main (int argc, LPCTSTR argv [])
{
/* Buffer to receive current directory allows
CR/LF at the end of the longest possible path. */
TCHAR pwdBuffer [DIRNAME_LEN];
– 73 –
GetCurrentDirectory (2/2)
DWORD LenCurDir;
LenCurDir = GetCurrentDirectory
(DIRNAME_LEN, pwdBuffer);
if (LenCurDir == 0)
ReportError (TEXT
("Failure getting pathname\n"), 1, TRUE);
if (LenCurDir > DIRNAME_LEN)
ReportError (TEXT
("Pathname is too long\n"), 2, FALSE);
PrintMsg (GetStdHandle (STD_OUTPUT_HANDLE),
pwdBuffer);
return 0;
}
– 74 –
FILE ATTRIBUTES AND
FILE SEARCHING (1/2)
HANDLE FindFirstFile (LPCTSTR lpSearchFile,
LPWIN32_FIND_DATA lpffd)
Return: A “search handle”
INVALID_HANDLE_VALUE indicates failure
Parameters
– 75 –
lpSearchFile — Points to directory or pathname. Wildcards
are OK (* and ?)
lpffd — Points to a WIN32_FIND_DATA structure
FILE ATTRIBUTES AND
FILE SEARCHING (2/2)
typedef struct _WIN32_FIND_DATA {
DWORD dwFileAttributes; /* see CreateFile */
FILETIME ftCreationTime; /* 64-bit int */
FILETIME ftLastAccessTime;
FILETIME ftLastWriteTime;
DWORD nFileSizeHigh;
DWORD nFileSizeLow;
DWORD dwReserved0;
DWORD dwReserved1;
TCHAR cFileName [MAX_PATH]; /* file name */
TCHAR cAlternateFileName [14]; /* 8.3 name */
} WIN32_FIND_DATA;
– 76 –
FILES AND DIRECTORIES (1/5)
BOOL FindNextFile (HANDLE hFindFile,
LPWIN32_FIND_DATA lpffd)
FALSE when no more files satisfy the search pattern
BOOL FindClose (HANDLE hFindFile)
– 77 –
Exception: This is an example of a HANDLE that is not closed
with CloseHandle.
FILES AND DIRECTORIES (2/5)
File attributes can be obtained individually
Usually from the HANDLE rather than file name
DWORD GetFileSize (HANDLE hFile,
LPDWORD lpdwFileSizeHigh)
Return: The low-order component of the file size
– 78 –
0xFFFFFFFF indicates a possible error; check GetLastError
FILES AND DIRECTORIES (3/5)
DWORD GetFileInformationByHandle (HANDLE hFile)
Use GetCompressedFileSize to test for an empty file
– 79 –
if you have the file name but do not have an open handle
FILES AND DIRECTORIES (4/5)
BOOL GetFileTime (HANDLE hFile,
LPFILETIME lpftCreation,
LPFILETIME lpftLastAccess,
LPFILETIME lpftLastWrite)
BOOL FileTimeToSystemTime(
CONST FILETIME * lpFileTime,
LPSYSTEMTIME lpSystemTime)
LPSYSTEMTIME has WORD members for the time
components:
wMonth, …, wMilliseconds
FILETIME (64 bits) is elapsed 100 ns units since
Jan 1, 1601
– 80 –
wYear,
More than 60,000 years can be represented
FILES AND DIRECTORIES (5/5)
DWORD GetFileAttributes (LPCTSTR lpFileName)
Return: The file attributes or 0xFFFFFFFF in case of failure
The attributes can be tested for the following values:
FILE_ATTRIBUTE_DIRECTORY
FILE_ATTRIBUTE_NORMAL
FILE_ATTRIBUTE_READONLY
FILE_ATTRIBUTE_TEMPORARY
SetFileAttributes
– 81 –
Allows you to change attributes in a named file
TEMPORARY FILE NAMES (1/2)
UINT GetTempFileName (LPCTSTR lpPath,
LPCTSTR lpPrefix, UINT uUnique,
LPTSTR lpTempFile)
Return: A unique numeric value used to create the file
name
– 82 –
uUnique if uUnique is non-zero
On failure, the return value is zero.
TEMPORARY FILE NAMES (2/2)
lpPath
Directory where you want the temporary file
lpPrefix
Prefix of the temporary name
uUnique
Normally zero to generate a unique four-digit suffix
lpTempFile
– 83 –
Points to buffer for the temporary file name
FILES AND DIRECTORIES (UNIX & Libc)
Directory scan functions in UNIX
opendir, readdir, closedir,…
No directory handling functions in Libc
– 84 –