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 –