获取最后创建（修改）的文件

Question

I have a program that created files and fill them with data , it doesn't matter what exactly , it named them based of the actual time (YYYYMMDDHHMMSS). Now I want to always open the last created file , meaning the recent one, is this possible in C ? if yeah, I'll be greatful for any hint ?

UPDATE

I need to make it clear.

say I have a string that I want to use like :

..............
FILE* input = NULL;
char* fileName = NULL;
...............// in some getting the name of the last modified file 
   and than open it 
inp = fopen(fileName,"rb");

Answer 1

The ftw() function may be useful here. It will call a function (which you need to write) for every file and directory in the directory. Your function will decide if its argument is newer than whatever arguments it's seen before, and if so, records it in a global variable.

One caveat is that ftw will look at every file in every subdirectory. That may not be what you want. But if that's OK, using ftw will make your code more concise, because it does the directory scanning and statting for you. Here's an example I wrote that will find the most recently modified file in the current directory:

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>
#include <limits.h>
#include <string.h>
#include <ftw.h>

char newest[PATH_MAX];
time_t mtime = 0;

int checkifnewer(const char *path, const struct stat *sb, int typeflag)
{
    if (typeflag == FTW_F && sb->st_mtime > mtime) {
        mtime = sb->st_mtime;
        strncpy(newest, path, PATH_MAX);
    }
    return 0;
}

main()
{
    ftw(".", checkifnewer, 1); 
    printf("%s\n", newest);
}

Answer 2

This can be accomplished by using stat function.

Using stat() function you can get the file information. stat structure contains-

struct stat {
               dev_t     st_dev;     /* ID of device containing file */
               ino_t     st_ino;     /* inode number */
               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 ID (if special file) */
               off_t     st_size;    /* total size, in bytes */
               blksize_t st_blksize; /* blocksize for file system I/O */
               blkcnt_t  st_blocks;  /* number of 512B 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 */
           };

Check the each file time info with other files, which file have the highest time details, store that into another stat structure and do comparing for all the files. and finally open the file what you have stored in stat structure!

Answer 3

You don't have to extract file's timestamp to check which file was lastly created (which is expensive), instead use inotify() , see here . inotify() will tell you whenever a new file is created.

Answer 4

Scan the directory and remember the file with largest timestamp. If the filename follows YYYYMMDDHHMMSS format, then it is enough to find a file with the "greatest" filename, something like this:

char buffer[MAX_LEN];
void recentByName(const char* path, char* recent){
  DIR* dir  = opendir(path);
  struct dirent* entry;
  recent[0] = '\0';
  while (NULL != (entry = readdir(dir))) {
    if (!isExceptionalDir(entry->d_name)) {
      if (strncmp(recent, entry->d_name, MAX_LEN)<0) {
        strncpy(recent, entry->d_name, MAX_LEN);
      }
    }
  }
  closedir(dir);
}

However 3.stat() might be more reliable at giving the actual modification time, then try this:

void recentByModification(const char* path, char* recent){
  struct dirent* entry;
  time_t recenttime = 0;
  struct stat statbuf;
  DIR* dir  = opendir(path);
  while (NULL != (entry = readdir(dir))) {
    if (!isExceptionalDir(entry->d_name)) {
      sprintf(buffer, "%s/%s", path, entry->d_name);
      stat(buffer, &statbuf);
      if (statbuf.st_mtime > recenttime) {
        strncpy(recent, entry->d_name, MAX_LEN);
        recenttime = statbuf.st_mtime;
      }
    }
  }
  closedir(dir);
}

Note that the check "isExceptional()" omits the "." and ".." entries which seem to always be the newest.

Complete program listing:

#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <dirent.h>
#include <stdio.h>

#define MAX_LEN 1024

int isExceptionalDir(const char* name){
  if (name==NULL || name[0]=='\0') return 1;
  else if (name[0]=='.') {
    if (name[1]=='\0') return 1;
    else if (name[1]=='.' && name[2]=='\0') return 1;
  }
  return 0;
}

char buffer[MAX_LEN];

void recentByModification(const char* path, char* recent){
  struct dirent* entry;
  time_t recenttime = 0;
  struct stat statbuf;
  DIR* dir  = opendir(path);
  while (NULL != (entry = readdir(dir))) {
    if (!isExceptionalDir(entry->d_name)) {
      sprintf(buffer, "%s/%s", path, entry->d_name);
      stat(buffer, &statbuf);
      if (statbuf.st_mtime > recenttime) {
        strncpy(recent, entry->d_name, MAX_LEN);
        recenttime = statbuf.st_mtime;
      }
    }
  }
  closedir(dir);
}

void recentByName(const char* path, char* recent){
  DIR* dir  = opendir(path);
  struct dirent* entry;
  recent[0] = '\0';
  while (NULL != (entry = readdir(dir))) {
    if (!isExceptionalDir(entry->d_name)) {
      if (strncmp(recent, entry->d_name, MAX_LEN)<0) {
        strncpy(recent, entry->d_name, MAX_LEN);
      }
    }
  }
  closedir(dir);
}


char recent[MAX_LEN];

int main(int argc, const char* args[])
{
  if (argc < 2) {
    printf("Usage: %s path\n", args[0]);
    return 1;
  }
  for (int i=1; i<argc; i++) {
    recentByModification(args[i], recent);
    printf("%s\n", recent);
  }
}