Documents
Resources
Learning Center
Upload
Plans & pricing Sign in
Sign Out

Unix Warmup

VIEWS: 12 PAGES: 44

  • pg 1
									             Unix Warmup
Ssh -Y poseidon.cs.kent.edu
emacs ~/bin
(k)hexedit a.out
double * ys;
memcpy(ys,xs,size);
ys+=size;
Inode
df
du
          Directories, File info
The shell command ls provides information on
a file's
size, ownership, group, type
The shell command stat (on Linux systems)
provides, in addition,
device types, uid, gid, inode
access, modify, and change times
How does the program get this information?
File System Organization
          What is a directory?
It is a special kind of file that contains a list of
files and/or other directories. Every directory
contains the itesm “.” and “..”
opendir(name)-Opens a directory stream.
Returns a DIR *.
readdir(DIR *)-gets next record for directory
and returns a struct dirent *.
closedir(DIR *)-close the directory stream.
                        struct dirent
struct dirent
              {
                  long d_ino;                 /* inode number */
                  off_t d_off;                /* offset to this dirent */
                  unsigned short d_reclen;    /* length of this d_name */
                  char d_name [NAME_MAX+1];   /* file name (null­terminated) */
              }
                                Sample Code
/** ls1.c
 **   purpose  list contents of directory or directories
 **   action   if no args, use .  else list files in args
 **/
#include        <stdio.h>
#include        <sys/types.h>
#include        <dirent.h>
void do_ls(char []);
main(int ac, char *av[])
{ if ( ac == 1 )
                do_ls( "." );
        else
                while ( ­­ac ){
                        printf("%s:\n", *++av );
                        do_ls( *av );
                }
}
                                Sample Code
void do_ls( char dirname[] )
/*
 *      list files in directory called dirname
 */
{
        DIR             *dir_ptr;               /* the directory */
        struct dirent   *direntp;               /* each entry    */
        if ( ( dir_ptr = opendir( dirname ) ) == NULL )
                fprintf(stderr,"ls1: cannot open %s\n", dirname);
        else
        {
                while ( ( direntp = readdir( dir_ptr ) ) != NULL )
                        printf("%s\n", direntp­>d_name );
                closedir(dir_ptr);
        }
}
         Reading Inodes Data
The information about a file is stored in an
inode.
When the file system is created, a table of
inodes is created to store file information.
A directory only contains the name of a file and
the files inode number.
To find out the size, type, owner, etc of a file we
need to access its inode with the system call
stat.
                                        stat
NAME
       stat, fstat, lstat ­ get file status

SYNOPSIS
       #include <sys/types.h>
       #include <sys/stat.h>
       #include <unistd.h>

       int stat(const char *file_name, struct stat *buf);
       int fstat(int filedes, struct stat *buf);
       int lstat(const char *file_name, struct stat *buf);
                                      Stat
DESCRIPTION
       These  functions  return  information about the specified file.  You do
       not need any access rights to the file to get this information but  you
       need  search rights to all directories named in the path leading to the
       file.

       stat stats the file pointed to by file_name and fills in buf.

       lstat is identical to stat, except in the  case  of  a  symbolic  link,
       where the link itself is stat­ed, not the file that it refers to.

       fstat  is  identical  to stat, only the open file pointed to by filedes
       (as returned by open(2)) is stat­ed in place of file_name.
                                             Stat
      They all return a stat structure, which contains the following fields:
              struct stat {
                  dev_t         st_dev;      /* device */
                  ino_t         st_ino;      /* inode */
                  mode_t        st_mode;     /* protection */
                  nlink_t       st_nlink;    /* number of hard links */
                  uid_t         st_uid;      /* user ID of owner */
                  gid_t         st_gid;      /* group ID of owner */
                  dev_t         st_rdev;     /* device type (if inode device) */
                  off_t         st_size;     /* total size, in bytes */
                  blksize_t     st_blksize;  /* blocksize for filesystem I/O */
                  blkcnt_t      st_blocks;   /* number of blocks allocated */
                  time_t        st_atime;    /* time of last access */
                  time_t        st_mtime;    /* time of last modification */
                  time_t        st_ctime;    /* time of last status change */
              };
                             fileinfo.c
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
void show_stat_info(char *, struct stat *);
int main(int ac, char *av[])
{struct stat info;         /* buffer for file info */
    if (ac>1)
        if( stat(av[1], &info) != -1 ){
             show_stat_info( av[1], &info );
             return 0;
        }
        else
        perror(av[1]); /* report stat() errors */

    return 1;
}
                               fileinof.c
void show_stat_info(char    *fname, struct stat *buf)
{printf("    mode: %o\n",   buf->st_mode); /* type + mode   */
  printf(" links: %d\n",    buf->st_nlink);/* # links       */
  printf("   user: %d\n",   buf->st_uid); /* user id        */
  printf(" group: %d\n",    buf->st_gid); /* group id       */
  printf("   size: %d\n",   buf->st_size); /* file size     */
  printf("modtime: %d\n",   buf->st_mtime);/* modified      */
  printf("   name: %s\n",   fname );       /* filename      */
}
                          mode number




   1     0     0     0      0     0     0     1     1      0    1     0     0      1     0     0


                                               ­rw­rw­r­­
                                    umask
UMASK(2)                   Linux Programmer's Manual                  UMASK(2)
NAME
       umask ­ set file creation mask
SYNOPSIS
       #include <sys/types.h>
       #include <sys/stat.h>
       mode_t umask(mode_t mask);
DESCRIPTION
       umask sets the umask to mask & 0777.
       The  umask  is  used  by  open(2)  to set initial file permissions on a
       newly­created file.  Specifically, permissions in the umask are  turned
       off  from  the  mode  argument  to open(2) (so, for example, the common
       umask default value of 022 results in new files being created with per­
       missions  0666  &  ~022  = 0644 = rw­r­­r­­ in the usual case where the
       mode is specified as 0666).
                   Using Masks




Stat constants
#define S_IFMT     0170000  /* bitmask for the file type bitfields*/
#define S_IFSOCK   0140000   /*socket*/
Stat macros:
#define S_ISFIFO(m)  (((m) & 0170000)) == (0010000))

Macros and constants listed in man pages
                               Masks
       S_IFMT     0170000   bitmask for the file type bitfields
       S_IFSOCK   0140000   socket
       S_IFLNK    0120000   symbolic link
       S_IFREG    0100000   regular file
       S_IFBLK    0060000   block device
       S_IFDIR    0040000   directory
       S_IFCHR    0020000   character device
       S_IFIFO    0010000   fifo
                             Masks
        S_ISUID    0004000   set UID bit
       S_ISGID    0002000   set GID bit (see below)
       S_ISVTX    0001000   sticky bit (see below)
       S_IRWXU    00700     mask for file owner permissions
       S_IRUSR    00400     owner has read permission
       S_IWUSR    00200     owner has write permission
       S_IXUSR    00100     owner has execute permission
       S_IRWXG    00070     mask for group permissions
       S_IRGRP    00040     group has read permission
       S_IWGRP    00020     group has write permission
       S_IXGRP    00010     group has execute permission
       S_IRWXO    00007     mask for permissions for others (not in group)
       S_IROTH    00004     others have read permission
             Setting mode bits
The mode bits can be set with open:
fid = open(filestr, O_CREAT|O_WRONLY|O_TRUNC,
            S_IRWXU|S_IRGRP|S_IROTH)
In a shell, one can use chmod:
    chmod u+rwx,g+r,o+r myfile
                                    getpwuid

     struct passwd *getpwuid(uid_t uid);
     struct passwd *getpwnam(const char *name);
            struct passwd {
                  char    *pw_name;      /* user name */
                  char    *pw_passwd;    /* user password */
                  uid_t   pw_uid;        /* user id */
                  gid_t   pw_gid;        /* group id */
                  char    *pw_gecos;     /* real name */
                  char    *pw_dir;       /* home directory */
                  char    *pw_shell;     /* shell program */
            };
                                   getgrgid
      struct group *getgrnam(const char *name);
       struct group *getgrgid(gid_t gid);


      struct group {
             char    *gr_name;      /* group name */
             char    *gr_passwd;    /* group password */
             gid_t   gr_gid;        /* group id */
             char    **gr_mem;      /* group members */
       };



     Note: a users can be in more than one group.
         Set UID and Set GID bits
For executable files if these bits are set, the the process will run with the
user and/or group permissions of the owner of the file rather than the user
that started the process
The set GID bit (S_ISGID) has several special uses: For a directory it
indicates that BSD semantics is to be used for that directory: files created
there inherit their group ID from the directory, not from the effective gid of
the creating process, and directories created there will also get the S_ISGID
bit set. For a file that does not have the group execution bit (S_IXGRP)
set, it indicates mandatory file/record locking.
The 'sticky' bit (S_ISVTX) on a directory means that a file in that directory
 can be renamed or deleted only by the owner of the file, by the owner of
the directory, and by root.
                                 links
stat reports the the number of links associated with an object. What is that?
When a file is added to a directory, a link is established. When it is removed
its link to that directory is removed. A file can be linked to any number of
different directories and have any number of different names in a directory.
The shell commands link and ln and the system call link will create links
between files in the same file system.
To link files in different file systesm use a symbolic (ln -s, symlink) link.
Modification and Access Times
Modify: The last time the file was written to
Access: The last time the file was read
Change: The last time the permission bits were
changed.
One can change the Access and Modify times
with utime and touch.
      Ownership and Group
The shell command and system command
chown can change the ownership of a file
The shell command chgrp and system
command chown can change the group of a
file.
                    Exercise 3.18

Recursive ls. Standard ls supports the ­R option. This option lists the 
contents of a directory and the contents of all directories below it.
Modify ls2.c to support the ­R option. Windows program will need to use 
GetFileAttributes.


Due February 9
                       C issues


C  Question: What does 
strutptr= (struct mystrct *) malloc(nstructs * sizeof(struct mystrct));
do?
                    safe_read
    
size_t safe_read(int fd, void *buf, size_t count)
{
        size_t n;
        do {
                n = read(fd, buf, count);
        } while (n < 0 && errno == EINTR);
        return n;
}
              Windows: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) 
Define UNICODE before #include <windows.h>
Also define _UNICODE consistently for the generic C library  library
                 Unicode Strings
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 *
                                       _?
TEXT vs. _TEXT vs. _T, and UNICODE vs. _UNICODE
The plain versions without the underscore affect the character set the Windows 
header files treat as default. So if you define UNICODE, then GetWindowText will 
map to GetWindowTextW instead of GetWindowTextA, for example. Similarly, 
the TEXT macro will map to L"..." instead of "...". 
The versions with the underscore affect the character set the C runtime header files 
treat as default. So if you define _UNICODE, then _tcslen will map to wcslen 
instead of strlen, for example. Similarly, the _TEXT macro will map to L"..." 
instead of "...". 
 
                   C runtime 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 (language specific) (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
                    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
FILE AND DIRECTORY MANAGEMENT
BOOL DeleteFile (LPCTSTR lpFileName)
You cannot delete an open file in Windows NT
(You can in Windows 9x)
     FILE AND DIRECTORY MANAGEMENT
 Renaming Files
  BOOL MoveFile (LPCTSTR lpExisting,
  LPCTSTR lpNew)
   Source and target files must be on the same drive. Fails if file lpNew exists.
 BOOL MoveFileEx (LPCTSTR lpExisting,
  LPCTSTR lpNew, DWORD dwFlags)
   Source and target files can be on different drives. Succeeds if lpNew exists.

Note: There are no soft links as in UNIX
Shortcuts are not the same thing; they are only recognized by the visual shell
                     Renaming

 Parameters
 lpExisting — The name of the existing file or directory
 lpNew — Cannot exist with MoveFile
Directories must be on same file system. If NULL the existing 
file is deleted
 dwFlags
MOVEFILE_REPLACE_EXISTING
To replace an existing file
MOVEFILE_COPY_ALLOWED
Copy then delete
                   Directories

BOOL CreateDirectory (LPCTSTR lpPath,
 LPSECURITY_ATTRIBUTES lpsa)
BOOL RemoveDirectory (LPCTSTR lpPath)
lpPath
Points to a null­terminated string with the directory name
                           Directories
 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:"));
Will set the C: drive directory to its current value
                           Directories
 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
Zero if the function fails
                         Directories

 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
Points to the buffer to receive the pathname string
                            Directories
 HANDLE FindFirstFile (LPCTSTR lpFilename,
                                         , LPWIN32_FIND_DATA lpffd);
      Return:
A search handle. INVALID_HANDLE_VALUE indicates failure.
     FindFirstFile examines both subdirectory and filenames, looking for a  
    Name  match  (could  be  "*").  The  returned  handle  is  used  in  subsequent 
searches.
                      typedef struct _WIN32_FIND_DATA {
                        DWORD dwFileAttributes;
                        FILETIME ftCreationTime;
                        FILETIME ftLastAccessTime;
                        FILETIME ftLastWriteTime;
                        DWORD nFileSizeHigh;
                        DWORD nFileSizeLow;
                        DWORD dwReserved0;
                        DWORD dwReserved1;
                        TCHAR cFileName[ MAX_PATH ];
                        TCHAR cAlternateFileName[ 14 ];
                      } WIN32_FIND_DATA,*PWIN32_FIND_DATA,
                       *LPWIN32_FIND_DATA;
                          Directories
 BOOL FindNextFile (HANDLE hFindFile,
                                        , LPWIN32_FIND_DATA lpffd);
     Return:
FALSE in cases of invalid arguments or if no more matching files can be 
found, in which cass the GetLastError will return 
ERROR_NO_MORE_FILES.
                                                                     
                     Directories
BOOL FindClose (HANDLE hFindFile,LPWIN32_FIND_DATA lpffd);
   
                                          PWD
/* cl ­DWIN32 PWD.C PRINTMSG.C REPRTERR.C */
#include "EvryThng.h"
#define DIRNAME_LEN MAX_PATH + 2
int _tmain (int argc, LPTSTR argv [])
{       /* Buffer to receive current directory allows for the CR,
                LF at the end of the longest possible path. */
        TCHAR pwdBuffer [DIRNAME_LEN];
        DWORD LenCurDir;
        LenCurDir = GetCurrentDirectory (DIRNAME_LEN, pwdBuffer);
        if (LenCurDir == 0)
                ReportError (_T ("Failure getting pathname."), 1, TRUE);
        if (LenCurDir > DIRNAME_LEN)
                ReportError (_T ("Pathname is too long."), 2, FALSE);
       PrintMsg (GetStdHandle (STD_OUTPUT_HANDLE), pwdBuffer);
        return 0;
}

								
To top