URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [rtems/] [c/] [src/] [tests/] [psxtests/] [psxstat/] [test.c] - Blame information for rev 609

Go to most recent revision | Details | Compare with Previous | View Log


/*
 *  This test exercises stat() via fstat() and generates as many of the
 *  path evaluation cases as possible.
 *
 *  COPYRIGHT (c) 1989-1999.
 *  On-Line Applications Research Corporation (OAR).
 *
 *  The license and distribution terms for this file may be
 *  found in the file LICENSE in this distribution or at
 *  http://www.OARcorp.com/rtems/license.html.
 *
 *  $Id: test.c,v 1.2 2001-09-27 12:02:26 chris Exp $
 */
 
#include <tmacros.h>
#include <assert.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <limits.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <rtems.h>
#include <rtems/libio.h>
 
#define MAXSYMLINK 5   /* There needs to be a better way of getting this. */
 
 
/*
 *  List of files which should exist.
 */
 
char *Files[] = {
  "////dir1/\\//file1\\\\//",
  "/dir1/file2",
  "/dir1/file3",
  "/dir1/file4",
  "/dir1/dir1/file1",
  "../../..//dir1/./././dir1/ file1",
  "main.c",
 
};
 
/*
 *  List of directories which should exist.
 */
 
char *Directories[] = {
  "/dir1",
  "/dir2",
  "/dir3",
  "/dir4",
  "/dir1/dir1",
  "/./././dir1/ dir1",
  "/./././links",
  "///dir1/dir1/../../dir1/../symlinks/////",
 
};
 
char *Links_to_Dirs[]= {
  "dir1/dir1/../../links/dir1",
  "links/dir2",
  "links/dir3",
  "links/dir4",
  "links/dir1_dir1",
  "links/dir1_ dir1",
  "links/../links/../links/links",
 
};
 
char *Links_to_Files[]= {
  "links/dir1_file1",
  "links/dir1_file2",
  "links/dir1_file3",
  "links/dir1_file4",
  "links/dir1_dir1_f1",
  "links/dir1_dir1 f1",
 
};
 
char *Links_to_dirlinks[]= {
  "links/links/links/links_dir1",
  "links//links_dir2",
  "links//links_dir3",
  "links//links_dir4",
  "links//links_dir1_d1",
  "links//links_dir1 d1",
  "links//links_links",
 
};
 
char *Links_to_filelinks[]= {
  "links///links_d1_file1",
  "links///links_d1_file2",
  "links///links_d1_file3",
  "links///links_d1_file4",
  "links///links_d1_d1_f1",
  "links///links_r1_d1 f1",
 
};
 
char *SymLinks[]= {
  "/symlinks/a_file_symlink",
  "/symlinks/a_dir_symlink",
  "/symlinks/a_link_symlink",
  "../symlinks/no_file",
  "/symlinks/a_dir_symlink/a_file_symlink",
 
};
 
/*
 *  List of absolute paths to stat.
 */
 
char *Good_absolute_paths[] = {
  "/dev",
  "////dir1/\\//file1\\\\//",
  "/dir1/\\\\/file2",
  "/dir1/file3/////\\\\\\",
  "/dir1/file4",
  "/dir1/dir1/file1",
  "/dir1/dir1/ file1",
  "/dir1",
  "/dir2//////\\",
  "/dir3",
  "/dir4",
  "/dir1/dir1",
  "/dir1/ dir1///\\\\",
  "/\\/\\/\\/\\/\\/\\/links\\/\\/\\/\\/\\/\\",
 
};
 
 
char *Bad_paths[] = {
  "/links/ENAMETOOLONG__________________________",
  "/dir1/file4/NOTADIR",
  "/dir1/dir1/EACCES__",
 
};
 
/*
 *  List of relative paths to stat.
 */
 
char *Good_relative_paths[] = {
  "dev",
  "dir1/\\//file1\\\\//",
  "dir1/\\\\/file2",
  "dir1/file3/////\\\\\\",
  "dir1/file4",
  "dir1/dir1/file1",
  "dir1/dir1/ file1",
  "dir1",
  "dir2//////\\",
  "dir3",
  "dir4",
  "dir1/dir1",
  "dir1/ dir1///\\\\",
  "main.c",
 
};
 
/*
 *  Do a stat on a single file and report the status.
 */
 
void stat_a_file(
  const char *file
)
{
  int         status;
  struct stat statbuf;
  int         major1;
  int         minor1;
  int         major2;
  int         minor2;
 
 
  assert( file );
 
  printf( "stat( %s ) returned ", file );
  fflush( stdout );
 
  status = stat( file, &statbuf );
 
  if ( status == -1 ) {
    printf( ": %s\n", strerror( errno ) );
  } else {
 
    rtems_filesystem_split_dev_t( statbuf.st_dev, major1, minor1 );
    rtems_filesystem_split_dev_t( statbuf.st_rdev, major2, minor2 );
 
 
    printf("\n\tst_dev     (0x%x:0x%x)\n", major1, minor1 );
    printf(  "...st_ino     %x\n", (int) statbuf.st_ino );
    printf(  "...st_mode    %o\n", statbuf.st_mode );
    printf(  "...st_nlink   %x\n", statbuf.st_nlink );
    printf(  "...st_uid     %d\n", statbuf.st_uid );
    printf(  "...st_gid     %d\n", statbuf.st_gid );
    printf(  "...st_rdev    (0x%x:0x%x)\n", major2, minor2 );
    printf(  "...st_size    %d\n",(unsigned int) statbuf.st_size );
    printf(  "...st_atime   %s", ctime( &statbuf.st_atime ) );
    printf(  "...st_mtime   %s", ctime( &statbuf.st_mtime ) );
    printf(  "...st_ctime   %s", ctime( &statbuf.st_ctime ) );
#if defined(__svr4__) && !defined(__PPC__) && !defined(__sun__)
    printf(  "...st_blksize %x\n", statbuf.st_blksize );
    printf(  "...st_blocks  %x\n", statbuf.st_blocks );
#endif
 
  }
}
 
/*
 *  stat() multiple files at a time
 */
 
void stat_multiple_files(
  char **files
)
{
  int    i;
 
  i = 0;
  while ( files[i] ) {
    stat_a_file( files[i] );
    i++;
  }
}
 
/*
 *  chown() multiple files at a time
 */
void chown_multiple_files(
  char **files
)
{
  int    i;
  uid_t  st_uid;
  gid_t  st_gid;
 
  st_uid = geteuid();
  st_gid = getegid();
 
  i = 0;
  while ( files[i] ) {
    printf("Change group of %s\n", files[i]);
    chown( files[i], st_uid, (st_gid+1) );
    stat_a_file( files[i] );
 
    printf("Change owner of %s\n", files[i]);
    chown( files[i], (st_uid+1), st_gid );
    stat_a_file( files[i] );
    i++;
  }
 
}
 
 
 
/*
 *  mknod() multiple files at a time
 */
 
void make_multiple_files(
  char **files
)
{
  int    i;
  int    status;
 
  i = 0;
  while ( files[i] ) {
    printf( "Making file %s\n", files[i] );
    status = mknod( files[i], ( S_IFREG | S_IROTH|S_IWOTH ), 0LL );
    assert( !status );
    i++;
  }
  puts( "" );
}
 
void make_multiple_bad_files(
  char **files
)
{
  int    i;
  int    status;
 
  i = 0;
  while ( files[i] ) {
    printf( "Making file %s ", files[i] );
    status = mknod( files[i], ( S_IFREG | S_IROTH|S_IWOTH ), 0LL );
    assert( status );
    printf( ": %s\n", strerror( errno ) );
    i++;
  }
  puts( "" );
}
 
void make_multiple_links(
  char **existing,
  char **new
)
{
  int    i;
  int    status;
 
  i = 0;
  while ( new[i] && existing[i] ) {
    printf( "Making file %s\n", new[i] );
    status = link( existing[i], new[i] );
    assert( !status );
    i++;
  }
  puts( "" );
 
  status = link( "fred", "bob" );
  assert( status == -1 );
 
  status = link( existing[1], "doug/bob" );
  assert( status == -1 );
}
 
 
void make_too_many_links()
{
  int    i;
  int    status;
  char   name [20];
 
  status = mkdir("/dummy", S_IRWXU );
  assert( status == 0 );
 
  for (i=1; i<= LINK_MAX; i++) {
 
    sprintf(name,"/LinkName%d",i);
    printf( "Making file %s\n", name );
    status = link("/dummy" , name );
    if( i < LINK_MAX )
       assert( !status );
    else
       assert( status == -1 );
 
  }
}
 
 
void make_a_symlink(
  char *existing,
  char *new
)
{
  int    status;
  char   buf[100];
  int    len;
 
  memset( buf, 0, 100 );
 
  printf( "Making file %s\n", new );
  status = symlink( existing, new );
  assert( !status );
 
  printf( "Verify with readlink\n");
  status = readlink( new, buf, 100 );
  len = strlen( existing );
  assert ( status == len );
 
  status = readlink( new, buf, 3 );
  len = strlen( existing );
  if (len < 3 )
    assert( status == len );
  else
    assert( status == 3 );
 
  status = strcmp( existing, buf );
  assert( !status );
}
 
void make_multiple_symlinks()
{
 int  status;
 
 make_a_symlink( Files[0],             SymLinks[0] );
 make_a_symlink( Directories[0],       SymLinks[1] );
 make_a_symlink( Links_to_dirlinks[0], SymLinks[2] );
 make_a_symlink( "No_File",            SymLinks[3] );
 make_a_symlink( SymLinks[1],          SymLinks[4] );
 make_a_symlink( "//links",            "/symlinks/links"  );
 
 stat_a_file( SymLinks[0] );
 stat_a_file( SymLinks[1] );
 stat_a_file( SymLinks[2] );
 stat_a_file( SymLinks[3] );
 stat_a_file( SymLinks[4] );
 
 status = symlink(  "//links", "bob/frank" );
 assert (status == -1);
 
}
/*
void make_too_many_symlinks()
{
  int  i, status;
  char name1[8];
 
  for (i=1; i <= MAXSYMLINK; i++) {
    sprintf( name1, "SymLink%d", i );
    status = symlink( "/dummy", name1 );
    if( i < MAXSYMLINK )
       assert( !status );
    else
       assert( status == -1 );
  }
}
*/
void make_many_symlinks(
  char  *real_file,
  int    link_count
)
{
  int  i;
  char name1[5];
  char name2[5];
  char *link_file;
 
  link_file = real_file;
  for (i=1; i < link_count; i++) {
    sprintf( name1, "%d", i );
    make_a_symlink( link_file, name1 );
    strcpy( name2, name1 );
    link_file = name2;
  }
 
  for (i=1; i < link_count; i++) {
    sprintf( name1, "%d", i );
    stat_a_file( name1 );
  }
 
}
 
/*
 *  mkdir() multiple directories at a time
 */
 
void make_multiple_directories(
  char **files
)
{
  int    i;
  int    status;
 
  i = 0;
  while ( files[i] ) {
    printf( "Making directory %s\n", files[i] );
    status = mkdir( files[i], S_IRWXU );
    assert( !status );
    i++;
  }
  puts( "" );
}
 
/*
 * Cause faults.
 */
 
 
void Cause_faults()
{
  int                                   fd;
  int                                   status;
  char                                  longer_name[100];
  rtems_filesystem_mount_table_entry_t *mt_entry;
 
  /*
   * Verify chmod with an invalid type.
   */
 
  printf("\n\nPass an invalid mode to chmod should fail with EPERM \n" );
  status = chmod( Files[0], S_IFREG );
  assert( status == -1 );
  assert( errno == EPERM );
 
  /*
   * Try to chdir to a file.
   */
 
  printf("chdir to a file should fail with ENOTDIR\n");
  status = chdir( Files[0] );
  assert( status == -1 );
  assert( errno == ENOTDIR );
 
  /*
   * Change mode to read/write on a directory.
   * Verify directory works properly.
   */
 
  printf("Verify RWX permission on %s via access\n", Directories[0]);
  status = access( Directories[0], ( R_OK | W_OK | X_OK )  );
  assert( status == 0 );
 
  printf( "chmod of %s to Read/Write\n", Directories[0] );
  status = chmod( Directories[0], (S_IXGRP | S_IXOTH) );
  assert( status == 0 );
 
  printf( "chmod fred should fail with ENOENT\n" );
  status = chmod( "fred", (S_IXGRP | S_IXOTH) );
  assert( status == -1 );
  assert( errno == ENOENT );
 
  strcpy(longer_name, Directories[0] );
  strcat(longer_name, "/BADNAME" );
  printf( "Create under %s should fail with EACCES\n", Directories[0] );
  status = mkdir( longer_name , S_IRWXU );
  assert( status == -1 );
  assert( errno == EACCES );
 
  printf("chdir to %s should fail with EACCES\n", Directories[4] );
  status = chdir( Directories[4] );
  assert( status == -1 );
  assert( errno == EACCES );
 
  /*
   * Check stat with a NULL buffer.
   */
 
  printf("Stat with a NULL buffer should fail with EFAULT\n");
  status = stat( Directories[0], NULL );
  assert( status == -1 );
  assert( errno == EFAULT );
 
  /*
   * Set current to a directory with no owner permissions.
   * Verify it works properly.
   */
 
  printf( "\n\nchmod of %s to Read/Write\n", Directories[0] );
  status = chmod( Directories[0], (S_IXGRP | S_IXOTH) );
  assert( status == 0 );
 
  printf("mkdir %s should fail with EACCESS\n", longer_name );
  status = mkdir( longer_name , S_IRWXU );
  assert( status == -1 );
  assert( errno == EACCES );
 
  printf("\n%s Should exist ( access )\n",Directories[0] );
  status = access( Directories[0], F_OK );
  assert( status == 0 );
  printf("\n%s Should have read  permission( access )\n",Directories[0] );
  status = access( Directories[0], R_OK );
  assert( status != 0 );
  printf("\n%s Should have write permission( access )\n",Directories[0] );
  status = access( Directories[0], W_OK );
  assert( status != 0 );
  printf("\n%s Should not have execute permission( access )\n",Directories[0] );
  status = access( Directories[0], X_OK );
  assert( status != 0 );
 
  printf("\nRestore %s to RWX\n",Directories[0] );
  status = chmod( Directories[0], S_IRWXU );
  assert( status == 0 );
 
  printf("chdir to / \n");
  status = chdir( "/" );
  assert( status == 0 );
 
  /*
   * Remove one of the directories.
   * Verify links to the removed directory still work.
   */
 
  printf( "Remove %s\n", Directories[5] );
  status = rmdir( Directories[5] );
  assert( status == 0 );
 
  stat_a_file( Directories[5] );
  status = access( Directories[5], F_OK );
  assert( status != 0 );
 
  stat_a_file( Links_to_Dirs[5] );
  status = readlink( Links_to_Dirs[5], longer_name, 3 );
  assert( status == -1 );
  assert( errno == EINVAL );
 
  stat_a_file( Links_to_dirlinks[5] );
  printf("Chdir to %s\n", Links_to_Dirs[5] );
  status = chdir( Links_to_Dirs[5] );
  assert( status == 0 );
 
  /*
   * Verify we cannot move up from a node with no parent node.
   */
 
  printf("Chdir to .. should fail with ENOENT\n" );
  status = chdir( ".." );
  assert( status == -1 );
  assert( errno == ENOENT );
 
  /*
   * Create a subdirectory under the dangling node.
   */
 
  printf("mkdir ../t should fail with ENOENT\n" );
  status = mkdir( "../t" , S_IRWXU );
  assert( status == -1 );
  assert( errno == ENOENT );
 
  printf("mkdir t\n");
  status = mkdir( "t" , S_IRWXU );
  assert( status == 0 );
 
  printf("chdir to / \n");
  status = chdir( "/" );
  assert( status == 0 );
 
  /*
   * Check rmdir, rmnod, and unlink
   */
 
  printf("rmdir %s should fail with ENOTDIR\n", Links_to_Dirs[5] );
  status = rmdir( Links_to_Dirs[5] );
  assert( status == -1 );
  assert( errno == ENOTDIR );
 
  printf("unlink %s\n", Links_to_Dirs[5] );
  status = unlink( Links_to_Dirs[5] );
  assert( status == 0 );
 
  printf("unlink %s should fail with ENOTEMPTY\n", Links_to_dirlinks[5] );
  status = unlink(  Links_to_dirlinks[5] );
  assert( status == -1 );
  assert( errno == ENOTEMPTY );
 
  strcpy( longer_name,  Links_to_dirlinks[5] );
  strcat( longer_name, "/t");
  printf("rmdir %s\n", longer_name );
  status = rmdir( longer_name );
  assert( status == 0 );
 
  printf("unlink %s\n", Links_to_Dirs[5]);
  status = unlink( Links_to_dirlinks[5] );
  assert( status == 0 );
 
  status = chdir( Directories[0] );
  status = mkdir ( "my_mount_point", S_IRWXU );
  assert( status == 0 );
 
  printf("Attempting to mount IMFS file system at /dir1/my_mount_point \n");
  status = mount(
     &mt_entry,
     &IMFS_ops,
     RTEMS_FILESYSTEM_READ_WRITE,
     NULL,
     "/dir1/my_mount_point" );
  assert( status == 0 );
 
  printf("rmdir /dir1/my_mount_point should fail with EBUSY\n");
  status = rmdir ("/dir1/my_mount_point" );
  assert( status == -1 );
  assert( errno == EBUSY );
 
  printf( "Unmount /dir1/my_mount_point\n");
  status = unmount( "/dir1/my_mount_point" );
  assert( status == 0 );
 
  /*
   * Verify write permission is checked.
   */
 
  printf("chmod of %s to group and other execute\n", Files[0] );
  status = chmod (Files[0], (S_IXGRP | S_IXOTH) );
  assert( status == 0 );
 
  printf("Open %s for write should fail with EACCES\n", Files[0] );
  fd = open (Files[0], O_WRONLY);
  assert( fd == -1 );
  assert( errno == EACCES );
 
  printf("chmod of %s to User Execute and Read\n", Directories[3] );
  status = chmod (Directories[3], (S_IXUSR | S_IRUSR) );
  assert( status == 0 );
  strcpy(longer_name, Directories[3] );
  strcat(longer_name, "/NewFile" );
  printf("Mkdir of %s should fail with EACCES\n",longer_name );
  status = mkdir( longer_name, S_IRWXU );
  assert( status != 0 );
  assert( errno == EACCES );
 
  printf(" Making too many hard links.\n" );
  make_too_many_links( );
 
  printf( "pass fstat a null pointer should fail with EFAULT\n");
  status = fstat( fd, NULL );
  assert( status == -1 );
  assert( errno == EFAULT);
 
  /*
   * The current directory MUST be restored at the end of this test.
   */
 
  printf("chdir to / \n");
  status = chdir( "/" );
  assert( status == 0 );
 
}
 
void Show_Time()
{
  rtems_time_of_day time;
  rtems_status_code status;
 
  status = rtems_clock_get( RTEMS_CLOCK_GET_TOD, &time );
  printf(">>>>Current Time: ");
  print_time( " - rtems_clock_get - ", &time, "\n" );
}
 
/*
 *  main entry point to the test
 */
 
#if defined(__rtems__)
int test_main(void)
#else
int main(
  int    argc,
  char **argv
)
#endif
{
  rtems_status_code status;
  rtems_time_of_day time;
 
  puts( "\n\n*** STAT TEST 01 ***" );
 
  build_time( &time, 12, 31, 1988, 9, 0, 0, 0 );
  status = rtems_clock_set( &time );
 
  /*
   *  Create the files and directories for the test.
   */
  Show_Time();
 
  make_multiple_directories( Directories );
  make_multiple_files( Files );
  make_multiple_links( Directories,    Links_to_Dirs );
  make_multiple_links( Files,          Links_to_Files );
 
  status = rtems_task_wake_after( 5 * TICKS_PER_SECOND );
  make_multiple_links( Links_to_Dirs,  Links_to_dirlinks );
  status = rtems_task_wake_after( 5 * TICKS_PER_SECOND );
  make_multiple_links( Links_to_Files, Links_to_filelinks );
 
  status = rtems_task_wake_after( 5 * TICKS_PER_SECOND );
 
  /*
   *  Now go through all the absolute path.
   */
 
  puts( "Doing the stat() on all the good absolute paths" );
  stat_multiple_files( Good_absolute_paths );
 
  /*
   *  run through the relative paths.
   */
 
  puts( "\nDoing the stat() on all the good relative paths" );
  stat_multiple_files( Good_relative_paths );
 
  /*
   * Change directory and releative paths are now bad.
   */
 
  puts("\nchdir to dev");
  chdir("dev");
  puts("\nstat relative paths that are now bad");
  stat_multiple_files( Good_relative_paths );
 
  /*
   * Change directory to the link directory and follow links.
   */
 
  puts("\nchdir to ../links");
  chdir("../links");
  puts("Doing the stat() on good links\n");
  stat_multiple_files( Links_to_Dirs );
  stat_multiple_files( Links_to_Files );
  stat_multiple_files( Links_to_dirlinks  );
  stat_multiple_files( Links_to_filelinks );
 
  /*
   * Chmod on dir1/dir1.  This allows the error path to be hit.
   */
 
  printf( "chmod of %s to Read/Write\n", Directories[4] );
  chmod( Directories[4], (S_IROTH|S_IWOTH) );
  puts( "\nDoing the stat() on all the bad paths" );
 
  stat_multiple_files( Bad_paths );
  make_multiple_bad_files( Bad_paths );
 
  printf( "Return %s to RWX\n", Directories[4] );
  chmod( Directories[4], S_IRWXU );
 
 
  /*
   * Check out symbolic links.
   */
 
  make_multiple_symlinks();
  make_many_symlinks( "/symlinks", 10 );
 
  status = rtems_task_wake_after( 5 * TICKS_PER_SECOND );
  Cause_faults();
 
  status = rtems_task_wake_after( 5 * TICKS_PER_SECOND );
  chown_multiple_files( Files );
 
  status = rtems_task_wake_after( 5 * TICKS_PER_SECOND );
  chown_multiple_files( Links_to_Dirs );
 
  puts( "\n\n*** END OF STAT TEST 01 ***" );
  exit(0);
}
 
 
 
 
 
 
 

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [rtems/] [c/] [src/] [tests/] [psxtests/] [psxstat/] [test.c] - Blame information for rev 609

Line No.	Rev	Author	Line
1	30	unneback	`/*`
2			`* This test exercises stat() via fstat() and generates as many of the`
3			`* path evaluation cases as possible.`
4			`*`
5			`* COPYRIGHT (c) 1989-1999.`
6			`* On-Line Applications Research Corporation (OAR).`
7			`*`
8			`* The license and distribution terms for this file may be`
9			`* found in the file LICENSE in this distribution or at`
10			`* http://www.OARcorp.com/rtems/license.html.`
11			`*`
12			`* $Id: test.c,v 1.2 2001-09-27 12:02:26 chris Exp $`
13			`*/`
14
15			`#include <tmacros.h>`
16			`#include <assert.h>`
17			`#include <sys/stat.h>`
18			`#include <fcntl.h>`
19			`#include <limits.h>`
20			`#include <stdio.h>`
21			`#include <unistd.h>`
22			`#include <errno.h>`
23			`#include <string.h>`
24			`#include <rtems.h>`
25			`#include <rtems/libio.h>`
26
27			`#define MAXSYMLINK 5 /* There needs to be a better way of getting this. */`
28
29
30			`/*`
31			`* List of files which should exist.`
32			`*/`
33
34			`char *Files[] = {`
35			`"////dir1/\\//file1\\\\//",`
36			`"/dir1/file2",`
37			`"/dir1/file3",`
38			`"/dir1/file4",`
39			`"/dir1/dir1/file1",`
40			`"../../..//dir1/./././dir1/ file1",`
41			`"main.c",`
42
43			`};`
44
45			`/*`
46			`* List of directories which should exist.`
47			`*/`
48
49			`char *Directories[] = {`
50			`"/dir1",`
51			`"/dir2",`
52			`"/dir3",`
53			`"/dir4",`
54			`"/dir1/dir1",`
55			`"/./././dir1/ dir1",`
56			`"/./././links",`
57			`"///dir1/dir1/../../dir1/../symlinks/////",`
58
59			`};`
60
61			`char *Links_to_Dirs[]= {`
62			`"dir1/dir1/../../links/dir1",`
63			`"links/dir2",`
64			`"links/dir3",`
65			`"links/dir4",`
66			`"links/dir1_dir1",`
67			`"links/dir1_ dir1",`
68			`"links/../links/../links/links",`
69
70			`};`
71
72			`char *Links_to_Files[]= {`
73			`"links/dir1_file1",`
74			`"links/dir1_file2",`
75			`"links/dir1_file3",`
76			`"links/dir1_file4",`
77			`"links/dir1_dir1_f1",`
78			`"links/dir1_dir1 f1",`
79
80			`};`
81
82			`char *Links_to_dirlinks[]= {`
83			`"links/links/links/links_dir1",`
84			`"links//links_dir2",`
85			`"links//links_dir3",`
86			`"links//links_dir4",`
87			`"links//links_dir1_d1",`
88			`"links//links_dir1 d1",`
89			`"links//links_links",`
90
91			`};`
92
93			`char *Links_to_filelinks[]= {`
94			`"links///links_d1_file1",`
95			`"links///links_d1_file2",`
96			`"links///links_d1_file3",`
97			`"links///links_d1_file4",`
98			`"links///links_d1_d1_f1",`
99			`"links///links_r1_d1 f1",`
100
101			`};`
102
103			`char *SymLinks[]= {`
104			`"/symlinks/a_file_symlink",`
105			`"/symlinks/a_dir_symlink",`
106			`"/symlinks/a_link_symlink",`
107			`"../symlinks/no_file",`
108			`"/symlinks/a_dir_symlink/a_file_symlink",`
109
110			`};`
111
112			`/*`
113			`* List of absolute paths to stat.`
114			`*/`
115
116			`char *Good_absolute_paths[] = {`
117			`"/dev",`
118			`"////dir1/\\//file1\\\\//",`
119			`"/dir1/\\\\/file2",`
120			`"/dir1/file3/////\\\\\\",`
121			`"/dir1/file4",`
122			`"/dir1/dir1/file1",`
123			`"/dir1/dir1/ file1",`
124			`"/dir1",`
125			`"/dir2//////\\",`
126			`"/dir3",`
127			`"/dir4",`
128			`"/dir1/dir1",`
129			`"/dir1/ dir1///\\\\",`
130			`"/\\/\\/\\/\\/\\/\\/links\\/\\/\\/\\/\\/\\",`
131
132			`};`
133
134
135			`char *Bad_paths[] = {`
136			`"/links/ENAMETOOLONG__________________________",`
137			`"/dir1/file4/NOTADIR",`
138			`"/dir1/dir1/EACCES__",`
139
140			`};`
141
142			`/*`
143			`* List of relative paths to stat.`
144			`*/`
145
146			`char *Good_relative_paths[] = {`
147			`"dev",`
148			`"dir1/\\//file1\\\\//",`
149			`"dir1/\\\\/file2",`
150			`"dir1/file3/////\\\\\\",`
151			`"dir1/file4",`
152			`"dir1/dir1/file1",`
153			`"dir1/dir1/ file1",`
154			`"dir1",`
155			`"dir2//////\\",`
156			`"dir3",`
157			`"dir4",`
158			`"dir1/dir1",`
159			`"dir1/ dir1///\\\\",`
160			`"main.c",`
161
162			`};`
163
164			`/*`
165			`* Do a stat on a single file and report the status.`
166			`*/`
167
168			`void stat_a_file(`
169			`const char *file`
170			`)`
171			`{`
172			`int status;`
173			`struct stat statbuf;`
174			`int major1;`
175			`int minor1;`
176			`int major2;`
177			`int minor2;`
178
179
180			`assert( file );`
181
182			`printf( "stat( %s ) returned ", file );`
183			`fflush( stdout );`
184
185			`status = stat( file, &statbuf );`
186
187			`if ( status == -1 ) {`
188			`printf( ": %s\n", strerror( errno ) );`
189			`} else {`
190
191			`rtems_filesystem_split_dev_t( statbuf.st_dev, major1, minor1 );`
192			`rtems_filesystem_split_dev_t( statbuf.st_rdev, major2, minor2 );`
193
194
195			`printf("\n\tst_dev (0x%x:0x%x)\n", major1, minor1 );`
196			`printf( "...st_ino %x\n", (int) statbuf.st_ino );`
197			`printf( "...st_mode %o\n", statbuf.st_mode );`
198			`printf( "...st_nlink %x\n", statbuf.st_nlink );`
199			`printf( "...st_uid %d\n", statbuf.st_uid );`
200			`printf( "...st_gid %d\n", statbuf.st_gid );`
201			`printf( "...st_rdev (0x%x:0x%x)\n", major2, minor2 );`
202			`printf( "...st_size %d\n",(unsigned int) statbuf.st_size );`
203			`printf( "...st_atime %s", ctime( &statbuf.st_atime ) );`
204			`printf( "...st_mtime %s", ctime( &statbuf.st_mtime ) );`
205			`printf( "...st_ctime %s", ctime( &statbuf.st_ctime ) );`
206			`#if defined(__svr4__) && !defined(__PPC__) && !defined(__sun__)`
207			`printf( "...st_blksize %x\n", statbuf.st_blksize );`
208			`printf( "...st_blocks %x\n", statbuf.st_blocks );`
209			`#endif`
210
211			`}`
212			`}`
213
214			`/*`
215			`* stat() multiple files at a time`
216			`*/`
217
218			`void stat_multiple_files(`
219			`char **files`
220			`)`
221			`{`
222			`int i;`
223
224			`i = 0;`
225			`while ( files[i] ) {`
226			`stat_a_file( files[i] );`
227			`i++;`
228			`}`
229			`}`
230
231			`/*`
232			`* chown() multiple files at a time`
233			`*/`
234			`void chown_multiple_files(`
235			`char **files`
236			`)`
237			`{`
238			`int i;`
239			`uid_t st_uid;`
240			`gid_t st_gid;`
241
242			`st_uid = geteuid();`
243			`st_gid = getegid();`
244
245			`i = 0;`
246			`while ( files[i] ) {`
247			`printf("Change group of %s\n", files[i]);`
248			`chown( files[i], st_uid, (st_gid+1) );`
249			`stat_a_file( files[i] );`
250
251			`printf("Change owner of %s\n", files[i]);`
252			`chown( files[i], (st_uid+1), st_gid );`
253			`stat_a_file( files[i] );`
254			`i++;`
255			`}`
256
257			`}`
258
259
260
261			`/*`
262			`* mknod() multiple files at a time`
263			`*/`
264
265			`void make_multiple_files(`
266			`char **files`
267			`)`
268			`{`
269			`int i;`
270			`int status;`
271
272			`i = 0;`
273			`while ( files[i] ) {`
274			`printf( "Making file %s\n", files[i] );`
275			`status = mknod( files[i], ( S_IFREG \| S_IROTH\|S_IWOTH ), 0LL );`
276			`assert( !status );`
277			`i++;`
278			`}`
279			`puts( "" );`
280			`}`
281
282			`void make_multiple_bad_files(`
283			`char **files`
284			`)`
285			`{`
286			`int i;`
287			`int status;`
288
289			`i = 0;`
290			`while ( files[i] ) {`
291			`printf( "Making file %s ", files[i] );`
292			`status = mknod( files[i], ( S_IFREG \| S_IROTH\|S_IWOTH ), 0LL );`
293			`assert( status );`
294			`printf( ": %s\n", strerror( errno ) );`
295			`i++;`
296			`}`
297			`puts( "" );`
298			`}`
299
300			`void make_multiple_links(`
301			`char **existing,`
302			`char **new`
303			`)`
304			`{`
305			`int i;`
306			`int status;`
307
308			`i = 0;`
309			`while ( new[i] && existing[i] ) {`
310			`printf( "Making file %s\n", new[i] );`
311			`status = link( existing[i], new[i] );`
312			`assert( !status );`
313			`i++;`
314			`}`
315			`puts( "" );`
316
317			`status = link( "fred", "bob" );`
318			`assert( status == -1 );`
319
320			`status = link( existing[1], "doug/bob" );`
321			`assert( status == -1 );`
322			`}`
323
324
325			`void make_too_many_links()`
326			`{`
327			`int i;`
328			`int status;`
329			`char name [20];`
330
331			`status = mkdir("/dummy", S_IRWXU );`
332			`assert( status == 0 );`
333
334			`for (i=1; i<= LINK_MAX; i++) {`
335
336			`sprintf(name,"/LinkName%d",i);`
337			`printf( "Making file %s\n", name );`
338			`status = link("/dummy" , name );`
339			`if( i < LINK_MAX )`
340			`assert( !status );`
341			`else`
342			`assert( status == -1 );`
343
344			`}`
345			`}`
346
347
348			`void make_a_symlink(`
349			`char *existing,`
350			`char *new`
351			`)`
352			`{`
353			`int status;`
354			`char buf[100];`
355			`int len;`
356
357			`memset( buf, 0, 100 );`
358
359			`printf( "Making file %s\n", new );`
360			`status = symlink( existing, new );`
361			`assert( !status );`
362
363			`printf( "Verify with readlink\n");`
364			`status = readlink( new, buf, 100 );`
365			`len = strlen( existing );`
366			`assert ( status == len );`
367
368			`status = readlink( new, buf, 3 );`
369			`len = strlen( existing );`
370			`if (len < 3 )`
371			`assert( status == len );`
372			`else`
373			`assert( status == 3 );`
374
375			`status = strcmp( existing, buf );`
376			`assert( !status );`
377			`}`
378
379			`void make_multiple_symlinks()`
380			`{`
381			`int status;`
382
383			`make_a_symlink( Files[0], SymLinks[0] );`
384			`make_a_symlink( Directories[0], SymLinks[1] );`
385			`make_a_symlink( Links_to_dirlinks[0], SymLinks[2] );`
386			`make_a_symlink( "No_File", SymLinks[3] );`
387			`make_a_symlink( SymLinks[1], SymLinks[4] );`
388			`make_a_symlink( "//links", "/symlinks/links" );`
389
390			`stat_a_file( SymLinks[0] );`
391			`stat_a_file( SymLinks[1] );`
392			`stat_a_file( SymLinks[2] );`
393			`stat_a_file( SymLinks[3] );`
394			`stat_a_file( SymLinks[4] );`
395
396			`status = symlink( "//links", "bob/frank" );`
397			`assert (status == -1);`
398
399			`}`
400			`/*`
401			`void make_too_many_symlinks()`
402			`{`
403			`int i, status;`
404			`char name1[8];`
405
406			`for (i=1; i <= MAXSYMLINK; i++) {`
407			`sprintf( name1, "SymLink%d", i );`
408			`status = symlink( "/dummy", name1 );`
409			`if( i < MAXSYMLINK )`
410			`assert( !status );`
411			`else`
412			`assert( status == -1 );`
413			`}`
414			`}`
415			`*/`
416			`void make_many_symlinks(`
417			`char *real_file,`
418			`int link_count`
419			`)`
420			`{`
421			`int i;`
422			`char name1[5];`
423			`char name2[5];`
424			`char *link_file;`
425
426			`link_file = real_file;`
427			`for (i=1; i < link_count; i++) {`
428			`sprintf( name1, "%d", i );`
429			`make_a_symlink( link_file, name1 );`
430			`strcpy( name2, name1 );`
431			`link_file = name2;`
432			`}`
433
434			`for (i=1; i < link_count; i++) {`
435			`sprintf( name1, "%d", i );`
436			`stat_a_file( name1 );`
437			`}`
438
439			`}`
440
441			`/*`
442			`* mkdir() multiple directories at a time`
443			`*/`
444
445			`void make_multiple_directories(`
446			`char **files`
447			`)`
448			`{`
449			`int i;`
450			`int status;`
451
452			`i = 0;`
453			`while ( files[i] ) {`
454			`printf( "Making directory %s\n", files[i] );`
455			`status = mkdir( files[i], S_IRWXU );`
456			`assert( !status );`
457			`i++;`
458			`}`
459			`puts( "" );`
460			`}`
461
462			`/*`
463			`* Cause faults.`
464			`*/`
465
466
467			`void Cause_faults()`
468			`{`
469			`int fd;`
470			`int status;`
471			`char longer_name[100];`
472			`rtems_filesystem_mount_table_entry_t *mt_entry;`
473
474			`/*`
475			`* Verify chmod with an invalid type.`
476			`*/`
477
478			`printf("\n\nPass an invalid mode to chmod should fail with EPERM \n" );`
479			`status = chmod( Files[0], S_IFREG );`
480			`assert( status == -1 );`
481			`assert( errno == EPERM );`
482
483			`/*`
484			`* Try to chdir to a file.`
485			`*/`
486
487			`printf("chdir to a file should fail with ENOTDIR\n");`
488			`status = chdir( Files[0] );`
489			`assert( status == -1 );`
490			`assert( errno == ENOTDIR );`
491
492			`/*`
493			`* Change mode to read/write on a directory.`
494			`* Verify directory works properly.`
495			`*/`
496
497			`printf("Verify RWX permission on %s via access\n", Directories[0]);`
498			`status = access( Directories[0], ( R_OK \| W_OK \| X_OK ) );`
499			`assert( status == 0 );`
500
501			`printf( "chmod of %s to Read/Write\n", Directories[0] );`
502			`status = chmod( Directories[0], (S_IXGRP \| S_IXOTH) );`
503			`assert( status == 0 );`
504
505			`printf( "chmod fred should fail with ENOENT\n" );`
506			`status = chmod( "fred", (S_IXGRP \| S_IXOTH) );`
507			`assert( status == -1 );`
508			`assert( errno == ENOENT );`
509
510			`strcpy(longer_name, Directories[0] );`
511			`strcat(longer_name, "/BADNAME" );`
512			`printf( "Create under %s should fail with EACCES\n", Directories[0] );`
513			`status = mkdir( longer_name , S_IRWXU );`
514			`assert( status == -1 );`
515			`assert( errno == EACCES );`
516
517			`printf("chdir to %s should fail with EACCES\n", Directories[4] );`
518			`status = chdir( Directories[4] );`
519			`assert( status == -1 );`
520			`assert( errno == EACCES );`
521
522			`/*`
523			`* Check stat with a NULL buffer.`
524			`*/`
525
526			`printf("Stat with a NULL buffer should fail with EFAULT\n");`
527			`status = stat( Directories[0], NULL );`
528			`assert( status == -1 );`
529			`assert( errno == EFAULT );`
530
531			`/*`
532			`* Set current to a directory with no owner permissions.`
533			`* Verify it works properly.`
534			`*/`
535
536			`printf( "\n\nchmod of %s to Read/Write\n", Directories[0] );`
537			`status = chmod( Directories[0], (S_IXGRP \| S_IXOTH) );`
538			`assert( status == 0 );`
539
540			`printf("mkdir %s should fail with EACCESS\n", longer_name );`
541			`status = mkdir( longer_name , S_IRWXU );`
542			`assert( status == -1 );`
543			`assert( errno == EACCES );`
544
545			`printf("\n%s Should exist ( access )\n",Directories[0] );`
546			`status = access( Directories[0], F_OK );`
547			`assert( status == 0 );`
548			`printf("\n%s Should have read permission( access )\n",Directories[0] );`
549			`status = access( Directories[0], R_OK );`
550			`assert( status != 0 );`
551			`printf("\n%s Should have write permission( access )\n",Directories[0] );`
552			`status = access( Directories[0], W_OK );`
553			`assert( status != 0 );`
554			`printf("\n%s Should not have execute permission( access )\n",Directories[0] );`
555			`status = access( Directories[0], X_OK );`
556			`assert( status != 0 );`
557
558			`printf("\nRestore %s to RWX\n",Directories[0] );`
559			`status = chmod( Directories[0], S_IRWXU );`
560			`assert( status == 0 );`
561
562			`printf("chdir to / \n");`
563			`status = chdir( "/" );`
564			`assert( status == 0 );`
565
566			`/*`
567			`* Remove one of the directories.`
568			`* Verify links to the removed directory still work.`
569			`*/`
570
571			`printf( "Remove %s\n", Directories[5] );`
572			`status = rmdir( Directories[5] );`
573			`assert( status == 0 );`
574
575			`stat_a_file( Directories[5] );`
576			`status = access( Directories[5], F_OK );`
577			`assert( status != 0 );`
578
579			`stat_a_file( Links_to_Dirs[5] );`
580			`status = readlink( Links_to_Dirs[5], longer_name, 3 );`
581			`assert( status == -1 );`
582			`assert( errno == EINVAL );`
583
584			`stat_a_file( Links_to_dirlinks[5] );`
585			`printf("Chdir to %s\n", Links_to_Dirs[5] );`
586			`status = chdir( Links_to_Dirs[5] );`
587			`assert( status == 0 );`
588
589			`/*`
590			`* Verify we cannot move up from a node with no parent node.`
591			`*/`
592
593			`printf("Chdir to .. should fail with ENOENT\n" );`
594			`status = chdir( ".." );`
595			`assert( status == -1 );`
596			`assert( errno == ENOENT );`
597
598			`/*`
599			`* Create a subdirectory under the dangling node.`
600			`*/`
601
602			`printf("mkdir ../t should fail with ENOENT\n" );`
603			`status = mkdir( "../t" , S_IRWXU );`
604			`assert( status == -1 );`
605			`assert( errno == ENOENT );`
606
607			`printf("mkdir t\n");`
608			`status = mkdir( "t" , S_IRWXU );`
609			`assert( status == 0 );`
610
611			`printf("chdir to / \n");`
612			`status = chdir( "/" );`
613			`assert( status == 0 );`
614
615			`/*`
616			`* Check rmdir, rmnod, and unlink`
617			`*/`
618
619			`printf("rmdir %s should fail with ENOTDIR\n", Links_to_Dirs[5] );`
620			`status = rmdir( Links_to_Dirs[5] );`
621			`assert( status == -1 );`
622			`assert( errno == ENOTDIR );`
623
624			`printf("unlink %s\n", Links_to_Dirs[5] );`
625			`status = unlink( Links_to_Dirs[5] );`
626			`assert( status == 0 );`
627
628			`printf("unlink %s should fail with ENOTEMPTY\n", Links_to_dirlinks[5] );`
629			`status = unlink( Links_to_dirlinks[5] );`
630			`assert( status == -1 );`
631			`assert( errno == ENOTEMPTY );`
632
633			`strcpy( longer_name, Links_to_dirlinks[5] );`
634			`strcat( longer_name, "/t");`
635			`printf("rmdir %s\n", longer_name );`
636			`status = rmdir( longer_name );`
637			`assert( status == 0 );`
638
639			`printf("unlink %s\n", Links_to_Dirs[5]);`
640			`status = unlink( Links_to_dirlinks[5] );`
641			`assert( status == 0 );`
642
643			`status = chdir( Directories[0] );`
644			`status = mkdir ( "my_mount_point", S_IRWXU );`
645			`assert( status == 0 );`
646
647			`printf("Attempting to mount IMFS file system at /dir1/my_mount_point \n");`
648			`status = mount(`
649			`&mt_entry,`
650			`&IMFS_ops,`
651			`RTEMS_FILESYSTEM_READ_WRITE,`
652			`NULL,`
653			`"/dir1/my_mount_point" );`
654			`assert( status == 0 );`
655
656			`printf("rmdir /dir1/my_mount_point should fail with EBUSY\n");`
657			`status = rmdir ("/dir1/my_mount_point" );`
658			`assert( status == -1 );`
659			`assert( errno == EBUSY );`
660
661			`printf( "Unmount /dir1/my_mount_point\n");`
662			`status = unmount( "/dir1/my_mount_point" );`
663			`assert( status == 0 );`
664
665			`/*`
666			`* Verify write permission is checked.`
667			`*/`
668
669			`printf("chmod of %s to group and other execute\n", Files[0] );`
670			`status = chmod (Files[0], (S_IXGRP \| S_IXOTH) );`
671			`assert( status == 0 );`
672
673			`printf("Open %s for write should fail with EACCES\n", Files[0] );`
674			`fd = open (Files[0], O_WRONLY);`
675			`assert( fd == -1 );`
676			`assert( errno == EACCES );`
677
678			`printf("chmod of %s to User Execute and Read\n", Directories[3] );`
679			`status = chmod (Directories[3], (S_IXUSR \| S_IRUSR) );`
680			`assert( status == 0 );`
681			`strcpy(longer_name, Directories[3] );`
682			`strcat(longer_name, "/NewFile" );`
683			`printf("Mkdir of %s should fail with EACCES\n",longer_name );`
684			`status = mkdir( longer_name, S_IRWXU );`
685			`assert( status != 0 );`
686			`assert( errno == EACCES );`
687
688			`printf(" Making too many hard links.\n" );`
689			`make_too_many_links( );`
690
691			`printf( "pass fstat a null pointer should fail with EFAULT\n");`
692			`status = fstat( fd, NULL );`
693			`assert( status == -1 );`
694			`assert( errno == EFAULT);`
695
696			`/*`
697			`* The current directory MUST be restored at the end of this test.`
698			`*/`
699
700			`printf("chdir to / \n");`
701			`status = chdir( "/" );`
702			`assert( status == 0 );`
703
704			`}`
705
706			`void Show_Time()`
707			`{`
708			`rtems_time_of_day time;`
709			`rtems_status_code status;`
710
711			`status = rtems_clock_get( RTEMS_CLOCK_GET_TOD, &time );`
712			`printf(">>>>Current Time: ");`
713			`print_time( " - rtems_clock_get - ", &time, "\n" );`
714			`}`
715
716			`/*`
717			`* main entry point to the test`
718			`*/`
719
720			`#if defined(__rtems__)`
721			`int test_main(void)`
722			`#else`
723			`int main(`
724			`int argc,`
725			`char **argv`
726			`)`
727			`#endif`
728			`{`
729			`rtems_status_code status;`
730			`rtems_time_of_day time;`
731
732			`puts( "\n\n* STAT TEST 01 *" );`
733
734			`build_time( &time, 12, 31, 1988, 9, 0, 0, 0 );`
735			`status = rtems_clock_set( &time );`
736
737			`/*`
738			`* Create the files and directories for the test.`
739			`*/`
740			`Show_Time();`
741
742			`make_multiple_directories( Directories );`
743			`make_multiple_files( Files );`
744			`make_multiple_links( Directories, Links_to_Dirs );`
745			`make_multiple_links( Files, Links_to_Files );`
746
747			`status = rtems_task_wake_after( 5 * TICKS_PER_SECOND );`
748			`make_multiple_links( Links_to_Dirs, Links_to_dirlinks );`
749			`status = rtems_task_wake_after( 5 * TICKS_PER_SECOND );`
750			`make_multiple_links( Links_to_Files, Links_to_filelinks );`
751
752			`status = rtems_task_wake_after( 5 * TICKS_PER_SECOND );`
753
754			`/*`
755			`* Now go through all the absolute path.`
756			`*/`
757
758			`puts( "Doing the stat() on all the good absolute paths" );`
759			`stat_multiple_files( Good_absolute_paths );`
760
761			`/*`
762			`* run through the relative paths.`
763			`*/`
764
765			`puts( "\nDoing the stat() on all the good relative paths" );`
766			`stat_multiple_files( Good_relative_paths );`
767
768			`/*`
769			`* Change directory and releative paths are now bad.`
770			`*/`
771
772			`puts("\nchdir to dev");`
773			`chdir("dev");`
774			`puts("\nstat relative paths that are now bad");`
775			`stat_multiple_files( Good_relative_paths );`
776
777			`/*`
778			`* Change directory to the link directory and follow links.`
779			`*/`
780
781			`puts("\nchdir to ../links");`
782			`chdir("../links");`
783			`puts("Doing the stat() on good links\n");`
784			`stat_multiple_files( Links_to_Dirs );`
785			`stat_multiple_files( Links_to_Files );`
786			`stat_multiple_files( Links_to_dirlinks );`
787			`stat_multiple_files( Links_to_filelinks );`
788
789			`/*`
790			`* Chmod on dir1/dir1. This allows the error path to be hit.`
791			`*/`
792
793			`printf( "chmod of %s to Read/Write\n", Directories[4] );`
794			`chmod( Directories[4], (S_IROTH\|S_IWOTH) );`
795			`puts( "\nDoing the stat() on all the bad paths" );`
796
797			`stat_multiple_files( Bad_paths );`
798			`make_multiple_bad_files( Bad_paths );`
799
800			`printf( "Return %s to RWX\n", Directories[4] );`
801			`chmod( Directories[4], S_IRWXU );`
802
803
804			`/*`
805			`* Check out symbolic links.`
806			`*/`
807
808			`make_multiple_symlinks();`
809			`make_many_symlinks( "/symlinks", 10 );`
810
811			`status = rtems_task_wake_after( 5 * TICKS_PER_SECOND );`
812			`Cause_faults();`
813
814			`status = rtems_task_wake_after( 5 * TICKS_PER_SECOND );`
815			`chown_multiple_files( Files );`
816
817			`status = rtems_task_wake_after( 5 * TICKS_PER_SECOND );`
818			`chown_multiple_files( Links_to_Dirs );`
819
820			`puts( "\n\n* END OF STAT TEST 01 *" );`
821			`exit(0);`
822			`}`
823
824
825
826
827
828
829