symlink01.c

cygwin, 著名的在win32下模拟unix操作系统的东东

    int errno_val;
    int pass_msg;
    int (*test_setup)();
    int (*ck_test)();
    char *fn_arg[3];
    
} test_objects[] = {
    {SYMLINK, 0, 0, 0, creat_symlink, ck_symlink, {"%bc+eFhi!k", S_FILE, NULL}},
    {SYMLINK, 0, 0, 0, creat_symlink, ck_symlink,  {O_FILE, S_FILE, NULL}},
    {SYMLINK, 0, 0, 1, creat_both, ck_both, {O_FILE, S_FILE, O_FILE}},
    {SYMLINK, 1, EEXIST, 2, creat_symlink, ck_symlink, {O_FILE, S_FILE, NULL}},
    {SYMLINK, 1, ENAMETOOLONG, 3, creat_path_max, ck_path_max, {O_FILE, S_FILE, NULL}},
    {READLINK, 0, 0, 4, creat_symlink, ck_symlink, {O_FILE, S_FILE, NULL}},
    {READLINK, 0, 0, 4, creat_both, ck_both, {O_FILE, S_FILE, O_FILE}},
    {READLINK, 1, ENAMETOOLONG, 5, creat_path_max, ck_path_max, {O_FILE, S_FILE, NULL}},
    {READLINK, 1, EINVAL, 29, creat_object, ck_object, {O_FILE, NULL, NULL}},
    {STAT, 0, 0, 6, creat_both, ck_both, {O_FILE, S_FILE, O_FILE}},
    {STAT, 1, ENOENT, 7, creat_symlink, ck_symlink, {O_FILE, S_FILE, NULL}},
    {STAT, 1, ELOOP, 28, creat_symlink, ck_symlink, {S_FILE, S_FILE, NULL}},
    {LSTAT, 0, 0, 8, creat_symlink, ck_symlink, {O_FILE, S_FILE, NULL}},
    {LSTAT, 0, 0, 9, creat_both, ck_both, {O_FILE, S_FILE, O_FILE}},
    {LSTAT, 0, 0, 30, creat_object, ck_object, {O_FILE, NULL, NULL}},
    {MKDIR, 1, EEXIST, 10, creat_symlink, ck_symlink, {O_FILE, S_FILE, NULL}},
    {RMDIR, 1, ENOTDIR, 11, creat_symlink, ck_symlink, {O_FILE, S_FILE, NULL}},
    {CHDIR, 0, 0, 12, creat_symlink, ck_symlink, {O_FILE, S_FILE, O_FILE}},
    {CHDIR, 1, ENOENT, 13, creat_symlink, ck_symlink, {"%bc+eFhi!k", S_FILE, NULL}},
    {CHDIR, 1, ELOOP, 28, creat_symlink, ck_symlink, {S_FILE, S_FILE, NULL}},
    {LINK, 0, 0, 14, creat_both, ck_both, {O_FILE, S_FILE, O_FILE}},
    {LINK, 0, 0, 15, creat_symlink, ck_symlink, {O_FILE, S_FILE, NULL}},
    /* The following link test case is invalid - leaving it defined so */
    /* I don't have to change all the entries in the all_tcses array after link */
    {LINK, -1, -1, -1, creat_symlink, ck_symlink, {NULL, NULL, NULL}},
    {UNLINK, 0, 0, 16, creat_both, ck_both, {O_FILE, S_FILE, O_FILE}},
    {CHMOD, 0, 0, 17, creat_both, ck_both, {O_FILE, S_FILE, O_FILE}},
    {CHMOD, 1, ENOENT, 18, creat_symlink, ck_symlink, {O_FILE, S_FILE, NULL}},
    {CHMOD, 1, ELOOP, 28, creat_symlink, ck_symlink, {S_FILE, S_FILE, NULL}},
    {UTIME, 0, 0, 19, creat_both, ck_both, {O_FILE, S_FILE, O_FILE}},
    {UTIME, 1, ENOENT, 20, creat_symlink, ck_symlink, {O_FILE, S_FILE, NULL}},
    {UTIME, 1, ELOOP, 28, creat_symlink, ck_symlink, {S_FILE, S_FILE, NULL}},
    {RENAME, 0, 0, 21, creat_symlink, ck_symlink, {O_FILE, S_FILE, NULL}},
    {RENAME, 0, 0, 22, creat_both, ck_both, {O_FILE, S_FILE, O_FILE}},
    {RENAME, -1, EXDEV, 23, creat_both, ck_both, {O_FILE, S_FILE, O_FILE}},
    {OPEN, 0, 0, 24, creat_symlink, ck_symlink, {O_FILE, S_FILE, NULL}},
    {OPEN, 0, 0, 25, creat_both, ck_both, {O_FILE, S_FILE, O_FILE}},
    {OPEN, -1, EEXIST, 26, creat_symlink, ck_symlink, {O_FILE, S_FILE, O_FILE}},
    {OPEN, 1, ENOENT, 27, creat_symlink, ck_symlink, {O_FILE, S_FILE, NULL}},
    {OPEN, 1, ELOOP, 28, creat_symlink, ck_symlink, {S_FILE, S_FILE, NULL}}
};

/*
 * Define tcses
 */
struct tcses
{
    char *tcid;
    char *syscall;
    int test_cases;		/* number of entries in test_objects array */
    struct all_test_cases *tc_ptr;
    char *desc;
} all_tcses[] = {

   { SYMLINK,  "symlink",  5, &test_objects[0],
		"Make a Symbolic Link to a File" },
   { READLINK, "readlink", 4, &test_objects[5],
		"Reads Value of a Symbolic Link" },
   { STAT,     "stat",     3, &test_objects[9],
		"Gets File Status Indirectly From a Symbolic Link file" },
   { LSTAT,    "lstat",    3, &test_objects[12],
		"Get file Status About a Symbolic Link File" },
   { MKDIR,    "mkdir",    1, &test_objects[15],
		"Fail When Making a Directory File Indirectly from a symlink" },
   { RMDIR,    "rmdir",    1, &test_objects[16],
		"Fail When Removing a Directory File Indirectly from a symlink" },
   { CHDIR,    "chdir",    3, &test_objects[17],
		"Changes CWD Location Indirectly from a symlink" },
   { LINK,     "link",     2, &test_objects[20],
		"Creates a Link To a File Indirectly From a Symbolic" },
   { UNLINK,   "unlink",   1, &test_objects[23],
		"Removes a Link To a File but not the Object File" },
   { CHMOD,    "chmod",    3, &test_objects[24],
		"Change Object File Permissions Indirectly From a Symbolic" },
   { UTIME,    "utime",    3, &test_objects[27],
		"Set File Access And Modify Object File Times via symlink" },
   { RENAME,   "rename",   3, &test_objects[30],
		"Rename a Symbolic Link File And Not Any Object file" },
   { OPEN,     "open",     5, &test_objects[33],
		"Create/Open a File For Reading Or Writing via symlink" },
};

/*
 * Define GLOBAL variables
 */

int TST_TOTAL;
int TEST_RESULT;
time_t a_time_value = 100;
char  *TCID = NULL;
char  *Selectedtests = NULL;		/* Name (tcid) of selected test cases */
char test_msg[BUFMAX];
char full_path[PATH_MAX+1];
extern int Tst_count;
extern char *TESTDIR;
extern char *strrchr();
extern int errno;

struct stat asymlink, statter;
char Buffer[1024];
char Buf[1024];

char *Tcid = NULL;

option_t Options[] = {
    { "T:",  NULL, &Tcid },	    /* -T tcid option */
    { NULL, NULL, NULL }
};

/***********************************************************************
 * MAIN
 ***********************************************************************/
int
main(int argc, char *argv[])
{
    struct tcses *tcs_ptr, *get_tcs_info();
    int do_syscalltests();
    void cleanup();
    int lc;             /* loop counter */
    const char *msg;          /* message returned from parse_opts */


   /***************************************************************
    * parse standard options, and exit if there is an error
    ***************************************************************/
   if ( (msg=parse_opts(argc, argv, Options, &help)) != (char *) NULL ) {
        tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
        tst_exit();
   }

   /*
    * If the -T option was used, use that TCID or use the default
    */
   if ( Tcid != NULL ) {
       TCID = Tcid;
       Selectedtests=Tcid;

   }
   else {
       TCID = DEFAULT_TCID;
#ifndef ALL
       Selectedtests = DEFAULT_TCID;
#else
       Selectedtests = NULL;
#endif
    }

   /*
    * Get test case specification information and assign TST_TOTAL
    */
   if ((tcs_ptr=get_tcs_info(Selectedtests)) == NULL) {
      TST_TOTAL=1;
      tst_brkm(TBROK, cleanup,
	"Unknown symbolic link test case specification executed");
   }

   /***************************************************************
    * perform global setup for test
    ***************************************************************/

   setup();

    /***************************************************************
     * check looping state if -c option given
     ***************************************************************/
    for (lc=0; TEST_LOOPING(lc); lc++) {

        /* reset Tst_count in case we are looping. */
        Tst_count=0;

        /*
         * Execute tcs testing function and all defined test cases
         */
        do_syscalltests(tcs_ptr);

    }   /* End for TEST_LOOPING */

    /*
     * End appropriately
     */
    cleanup();

    return 0;
}

/***********************************************************************
 *  This function maps the name of the process to a test case specification
 *  defined in the all_tcses array of tcses structures.  Either a pointer
 *  to the mapped test case specification information is returned or a
 *  null pointer.
 *
 *      Argument is path to program name.
 ***********************************************************************/
struct tcses *get_tcs_info(ptr)
char *ptr;
{
    int ctr;
    struct tcses *tcs_ptr;

#if ALL
    if ( ptr == NULL ) {

	TST_TOTAL=0;
	for (ctr=1; ctr < sizeof(all_tcses)/sizeof(struct tcses); ctr++)
	TST_TOTAL += all_tcses[ctr].test_cases;
	return all_tcses;
    }
#endif

    
    for(ctr=0; ctr < (sizeof(all_tcses)/sizeof(struct tcses)); ctr++) {
       if ( strcmp(ptr, all_tcses[ctr].tcid) == 0 || 
	    strcmp(ptr, all_tcses[ctr].syscall) == 0 ) {
          tcs_ptr = &all_tcses[ctr];
	  TCID = all_tcses[ctr].tcid;
          TST_TOTAL=tcs_ptr->test_cases;
          return(tcs_ptr);
       }
       
    }
    return(NULL);
}

/***********************************************************************
 *  Determines if what path points at is a symbolic link file
 *
 *      Argument is path to symbolic link file.
 *
 *  Return status is one if a symbolic link file.  Zero if not a symbolic
 *  link file and a minus one if the path doesn't point at a file.
 ***********************************************************************/
int
see_if_a_symlink(path)
char *path;
{
   if (lstat(path, &asymlink) < 0)
      return(-1);

   if ((asymlink.st_mode & S_IFMT) == S_IFLNK)
      return(1);
   else
      return(0);
}

/***********************************************************************
 * This function performs without any hesitation, file(s) deletions
 ***********************************************************************/
void
delete_files(path1, path2)
char *path1, *path2;
{
   unlink(path1);
   unlink(path2);
}

/***********************************************************************
 *
 * This routine creates a symbolic link file.
 *
 *      Argument one is symbolic link pathname to point at.
 *      Argument two is name of symbolic link file.
 *
 ***********************************************************************/
int
creat_symlink(path1, path2)
char *path1, *path2;
{
   TEST( symlink(path1, path2) );
   errno=TEST_ERRNO;
   if (TEST_RETURN == -1) {
      TEST_RESULT=TBROK;
      sprintf(test_msg,
	"symlink(2) Failure when creating setup %s object file: errno:%d %s",
	path1, errno, strerror(errno));
      return(0);
   } 
   else {
	sprintf(Buf, "symlink(%s, %s) was succesful.\n", path1, path2);
	strcat(Buffer, Buf);
#if DEBUG
	tst_resm(TPASS, "symlink(%s, %s) was succesful.", path1, path2);
#endif
   }
   return(1);
}

/***********************************************************************
 *
 * This routine creates a regular file.
 *
 *      Argument one is a pathname
 *
 ***********************************************************************/
int
creat_object(path1)
char *path1;
{
   int fd;
   if ((fd=creat(path1, MODE)) == -1) {
      TEST_RESULT=TBROK;
      sprintf(test_msg,
	"creat(2) Failure when creating setup %s object file: errno:%d %s",
	path1, errno, strerror(errno));
      return(0);
   } 
   else {
	sprintf(Buf, "creat(%s, %#o) was succesful.\n", path1, MODE);
	strcat(Buffer, Buf);
#if DEBUG
	tst_resm(TPASS, "creat(%s, %#o) was succesful.", path1, MODE);
#endif
   }
   if (close(fd) == -1) {
      TEST_RESULT=TBROK;
      sprintf(test_msg,
	"close(2) Failure when closing setup %s object file: errno:%d %s",
	path1, errno, strerror(errno));
      return(0);
   }
   return(1);
}

/***********************************************************************
 *
 * This routine creates a symbolic link file and a regular file.
 *
 *      Argument one is a pathname of object file
 *      Argument two is symbolic link file name
 *      Argument three is regular file name
 *
 ***********************************************************************/
int
creat_both(path1, path2, path3)
char *path1, *path2, *path3;
{
   if (creat_symlink(path1, path2) == -1)
      return(0);
   else if (creat_object(path3) == -1)
      return(0);
   return(1);
}

/***********************************************************************
 *
 * This routine checks if symbolic link file is a symbolic link file.
 *
 *      Argument one is a pathname of object file
 *      Argument two is symbolic link file name
 *      Argument three is regular file name
 *
 ***********************************************************************/
int
ck_symlink(path1, path2, path3)
char *path1, *path2, *path3;
{
   int ret;

   if ((ret=see_if_a_symlink(path2)) == -1) {
      TEST_RESULT=TBROK;
      sprintf(test_msg,
	"lstat(2) Failure when accessing %s symbolic link file which should contain %s path to %s file ",
	path2, path1, path3);
      return(0);
   }
   else if (ret == 0) {
      TEST_RESULT=TBROK;
      sprintf(test_msg,
	"%s is not a symbolic link file which contains %s path to %s file",
	path2, path1, path3);
      return(0);
   }
   return(1);
}

/***********************************************************************
 *
 * This routine checks if symbolic link file points at object file.
 *
 *      Argument one is a pathname of object file
 *      Argument two is symbolic link file name
 *      Argument three is regular file name
 *
 ***********************************************************************/
int
ck_both(path1, path2, path3)