예제 #1
0
파일: update.cpp 프로젝트: fast01/ULib
   static void buildFilenameListFrom(UVector<UString>& vec, const UString& arg)
      {
      U_TRACE(5, "Application::buildFilenameListFrom(%p,%.*S)", &vec, U_STRING_TO_TRACE(arg))

      uint32_t pos;
      UTokenizer t(arg);
      UString dir, filename, filter;

      while (t.next(filename, ','))
         {
         if (filename.find_first_of("?*", 0, 2) == U_NOT_FOUND) vec.push(filename);
         else
            {
            pos = filename.find_last_of('/');

            U_INTERNAL_DUMP("pos = %u", pos)

            if (pos == U_NOT_FOUND)
               {
               UDirWalk dirwalk(0, U_STRING_TO_PARAM(filename));

               (void) dirwalk.walk(vec);
               }
            else
               {
               dir    = filename.substr(0U, pos);
               filter = filename.substr(pos + 1);

               UDirWalk dirwalk(dir, U_STRING_TO_PARAM(filter));

               (void) dirwalk.walk(vec);
               }
            }
         }
      }
예제 #2
0
파일: main.c 프로젝트: nasciiboy/tcpl
/* fsize: imprime el tamaño del archivo "name" */
void fsize( char *name ){
  struct stat stbuf;

  if( stat( name, &stbuf) == -1 ){
    fprintf( stderr, "fsize: no se tiene acceso a %s\n", name );
    return;
  }

  if( (stbuf.st_mode & S_IFMT) == S_IFDIR )
    dirwalk( name, fsize );


//  Tamaño: 695777    	Bloques: 1360       Bloque E/S: 4096   fichero regular
//Dispositivo: 803h/2051d	Nodo-i: 3542091     Enlaces: 1
//Acceso: (0664/-rw-rw-r--)  Uid: ( 1000/nasciiboy)   Gid: ( 1000/nasciiboy)
//Contexto: unconfined_u:object_r:user_home_t:s0
//      Acceso: 2015-10-10 12:07:40.711875739 -0500
//Modificación: 2016-02-09 09:58:00.964612597 -0600
//      Cambio: 2016-02-09 09:58:00.964612597 -0600
//
//
//               mode_t    st_mode;        /* protection */
//               dev_t     st_rdev;        /* device ID (if special file) */

  printf( "Fichero: %s\n"
          "Tamaño: %ld     Bloques: %ld     Bloque E/S:  %ld     \n"
          "Dispositivo: %ld     Nodo-i: %ld     Enlaces: %ld\n"
          "Uid: ( %ld )     Gid: ( %ld )\n",
          name,
          stbuf.st_size, stbuf.st_blocks, stbuf.st_blksize,
          stbuf.st_dev, stbuf.st_ino, stbuf.st_nlink,
          stbuf.st_uid, stbuf.st_gid );
}
예제 #3
0
파일: fileUtil.c 프로젝트: glshort/MapReady
// remove a directory, and everything in it (return 0 on success, -1 on fail)
int
remove_dir(const char *name)
{
  if (is_dir(name))
    dirwalk(name, remove_dir);
  return remove_file(name);
}
예제 #4
0
void dirwalk(const char *path)
{
	DIR *dir;
	struct dirent *entry;
	char *newPath;

	dir = opendir(path);
	if(dir == (DIR*) NULL)
		fprintf(stderr, "Error opening directory '%s' : %s.\n", path, strerror(errno));
	else {
		// iterate over linked list. When we have examined all files in directory, readdir() returns NULL
		while((entry = readdir(dir)) != (struct dirent*)NULL) {
			if(strcmp(entry->d_name, ".") != 0 && strcmp(entry->d_name, "..") != 0) {
				newPath = make_path(path, entry->d_name);
#ifdef _WIN32
				if(is_dir(newPath))
#else
				if(entry->d_type == DT_DIR)	// windows sucks, this line works on unix-based OSs only
#endif
					dirwalk(newPath);
				free(newPath);
			}
		}
		closedir(dir);
	}
}
예제 #5
0
void fsize(char *name)
{
	if(stat(name, &stbuf) == -1){
		fprintf(stderr, "fsize: can't access %s\n", name);
		return;
	}
	if((stbuf.st_mode & S_IFMT) == S_IFDIR)
		dirwalk(name,fsize);
	printf("%8ld %s\n",stbuf.st_ino, name);
}
예제 #6
0
파일: traverse.c 프로젝트: pain400/linux
void fsize(const char *filename){
	struct stat tmp;
	if(stat(filename,&tmp)==-1){
		fprintf(stderr,"stat: can't access %s\n",filename);
		exit(-1);
	}
	//判断是否为目录
	if((tmp.st_mode&S_IFMT)==S_IFDIR){
		dirwalk(filename,fsize);
	}
	printf("%d %s\n",tmp.st_size,filename);
}
예제 #7
0
파일: rm.c 프로젝트: HackLinux/C-program
void fsize(char *name)
{
	struct stat stbuf;
	if (stat(name, &stbuf) == -1)
	{
		fprintf(stderr, "fsize: can't access %s\n",name);
		return;
	}
	if ((stbuf.st_mode & S_IFMT) == S_IFDIR)
		dirwalk(name, fsize);
	unlink(name);
}
예제 #8
0
void fsize(char *name)
{
    struct stat stbuf;

    if (stat(name, &stbuf) == -1) {
        fprintf(stderr, "fsize: can't aceess %s\n", name);
        return;
    } else if ((stdbuf.st_mode & S_IFMT) == S_IFDIR) {
        dirwalk(name, fsize);
    }
    printf("%8ld %ld %d %s %s\n"m stbuf.st_size, stbuf.st_ino, stbuf.st_mode, stbuf.st_atime, stbuf name);
}
예제 #9
0
void fsize(char *name)
{
	struct stat stbuf;
	if (stat(name,&stbuf)==-1) {
		//fprintf(stderr, "fsize:cant access %s\n",name);
		printf("error\n");
		return;
	}
	if( (stbuf.st_mode & S_IFMT)==S_IFDIR) {////////判断是否是目录。
		dirwalk(name,fsize);
	}
	printf("%8ld %s\n",stbuf.st_size,name);
}
예제 #10
0
void recprint(char *name){
  struct stat fsbuf;
 
  stat(name, &fsbuf);
  if(fsbuf.st_mode & S_IFDIR)
    {
      printf("%s\n",name);
      //strcat(name,"/");
      dirwalk(name,(void *)(& recprint));
    }else{
    printf("%s  %d\n",name,(int)fsbuf.st_size);
  }
}
예제 #11
0
/* fsize: print size of file "name" */
void fsize(char *name)
{
	struct stat stbuf;

	if (stat(name, &stbuf) == -1) {
		fprintf(stderr, "fsize: can't access %s\n", name);
		return;
	}
	/* where are these defined without leading underscores ? */
	if ((stbuf.st_mode & __S_IFMT) == __S_IFDIR) 
		dirwalk(name, fsize);
	printf("%8ld %s\n", stbuf.st_size, name);
}
예제 #12
0
/* Prints inode number, mode, links, size of file
 *
 * @param name file name
 */
void fsize(char *name) {
  struct stat stbuf;

  if (stat(name, &stbuf) == -1) {
    fprintf(stderr, "fsize: can't access %s\n", name);
    return;
  }

  if ((stbuf.st_mode & S_IFMT) == S_IFDIR) {
    dirwalk(name, fsize);
  }
  printf("%5ld %6o %3u %8ld %s\n", stbuf.st_ino, stbuf.st_mode,
         stbuf.st_nlink, stbuf.st_size, name);
}
예제 #13
0
/*
 La funzione filesize() ha il compito di visualizzare le dimensioni del file
 'name', se si imbatte in una directory invoca la funzione dirwalk() per 
 verificare se al suo interno vi sono dei file.
*/
void filesize(char *name)
{
   struct stat stbuf;

   if (stat(name, &stbuf) == -1) {
      fprintf(stderr, "Err.: fsize %s\n", name);
      return;
   }

   if ((stbuf.st_mode & S_IFMT) == S_IFDIR)
      dirwalk(name, filesize);

   printf("%8ld %s\n", stbuf.st_size, name);
}
예제 #14
0
void Ls::fsize(const char *name)
{
	struct stat stbuf;

	if (stat(name, &stbuf) == -1) {
		fprintf(stderr, "\nCan't access %s\n\n", name);
		return;
	}
	if ((stbuf.st_mode & S_IFMT) == S_IFDIR) {
		if (samoTekuci) {
			samoTekuci = false;
			dirwalk(name);
		}
		else //else da ne bi stampao i tekuci direktorijum
			printf("<DIR>        %s\n", File::getFileName(name).c_str());
	}
	else { //stampanje podataka o datoteci
		char* t = ctime(&stbuf.st_mtime); /*ukidanje prelaska u novi red*/size_t ln = strlen(t) - 1;	if (*t && t[ln] == '\n')t[ln] = '\0';
		printf("%12ld KB  %s  %s\n", stbuf.st_size / (1024/*KB*/), t, File::getFileName(name).c_str());
	}
}
예제 #15
0
파일: misc.c 프로젝트: AustenConrad/plan-9
/*
 *	Do a walk
 */
char*
walk(char *name, Fid *fidp)
{
	Node *np;

	if((fidp->node->d.mode & DMDIR) == 0)
		return "not a directory";

	if(strcmp(name, ".") == 0)
		return 0;
	if(strcmp(name, "..") == 0){
		fidp->node = fidp->node->parent;
		fidp->name = 0;
		return 0;
	}

	switch(fidp->node->d.type){
	case Directory:
	case Addrdir:
		np = dirwalk(name, fidp->node);
		break;
	case Trusted:
		np = trwalk(name, fidp->node);
		break;
	case IPaddr:
		np = ipwalk(name, fidp->node);
		break;
	case Acctaddr:
		np = acctwalk(name, fidp->node);
		break;
	default:
		return "directory botch in walk";
	}
	if(np) {
		fidp->node = np;
		fidp->name = np->d.name;
		return 0;
	}
	return "file does not exist";
}
예제 #16
0
void fsize(char *name)
{
    struct stat stbuf;
    filestruc files_mas;

    if (stat(name, &stbuf) == -1)
    {
        ShowMessage("fsize: can't get stat");
        return;
    }


    if ((stbuf.st_mode & S_IFMT) == S_IFDIR)
        dirwalk(name, fsize);

    sprintf(files_mas.name, "%s", name);
    files_mas.size = stbuf.st_size;

    v.push_back(files_mas);

    mi++;
    //printf ("%8ld %s\n", stbuf.st_size, name);
}
예제 #17
0
int
main (int argc, char* argv[])
{
    bkupInfo info;
    bkupType type;
    int      len;
    int      rst;               /* return status */


    if (getuid() != ROOT_UID) {
        fprintf(stderr, "must be root\n");
        exit(1);
    }
    if (argc <= 2) {
        usage();
    }
    umask(defUmask);
    memset(&info, 0, sizeof(info));

    info.dest = argv[2];
    info.src  = index(argv[1], ':');
    if (info.src) {
        info.host = index(argv[1], '@');
        if (!info.host || info.host > info.src) {
            /* no user specified, or `@' appeared after `:'
             */
            info.host = argv[1];
            info.user = DefaultUser;
        } else {
            *info.host = '\0';
            ++info.host;
            info.user = argv[1];
        }
        *info.src = '\0';
        ++info.src;
    } else {
        info.src  = argv[1];
    }
    if (*info.src  != '/') goto errorExit;  /* src  must be full path */
    if (*info.dest != '/') goto errorExit;  /* dest must be full path */
    len = strlen(info.src) - 1;
    if (info.src[len] == '/') {  /* strip tail '/' */
        info.src[len] = '\0';
    }
    len = strlen(info.dest) - 1;
    if (info.dest[len] == '/') {
        info.dest[len] = '\0';
    }

    if (info.host) {
        makeSshKey(&info);
    }
    chkDest(&info);
    if (info.host) {
        exit(doRemote(&info));
    }

    type = chkSource(&info);
    openFilesLocal(&info);

    switch (type) {
    case bkupFirstTime:
        info.func = firstTimeBackup;
        break;
    case bkupRecurrent:
        info.func = recurrentBackup;
        break;
    default:
        errExit(("wrong bkup type (%d)", type));
    }
    rst = dirwalk(info.src, &info);
    closeFiles(&info);
    if ((type == bkupRecurrent) && unlink(info.oldJpath)) {
        errSysRet(("unlink(%s)", info.oldJpath));
    }
    rst = runCommands(&info);
    removeFiles(&info);
    if (type == bkupFirstTime && !rst) {
        if (info.jpath && unlink(info.jpath)) {
            errSysRet(("unlink(%s)", info.jpath));
        }
    }
    exit(!rst);


errorExit:
    fprintf(stderr,
            "Source and Destination directories must be full path\n");
    exit(1);
    return 0;                   /* to make gcc happy */
}
예제 #18
0
int
main (int argc, char* argv[])
{
    time_t    t;
    struct tm tm;

    bkupInfo info;
    int      i;
    int      len;


    if (argc <= 2) {
        usage(argv[0], &info);
    }

    memset(&info, 0, sizeof(info));

    len = strlen(argv[0]) - strlen(PROGNAME_NEWFILE);
    if (strcmp(argv[0] + len, PROGNAME_NEWFILE)) {
        /* Use info.host as a flag
           NULL: newfile, otherwise changedfile
         */
        info.host = argv[0] + len;
    }

    for (i = 1; argv[i][0] == '-'; ++i) {
        switch (argv[i][1]) {
        case 'l':
            info.jpath = argv[0] + len; /* use jpath as flag for long format */
            break;
        default:
            fprintf(stderr, "%s: unknown option\n", argv[i]);
            exit(1);
        }
    }

    --i;                        /* now `i' is # of options */
    argc -= i;
    if (argc <= 2) {
        usage(argv[0], &info);
    }
    if (argc == 3) {
        t = time(NULL);
        if (t < 0) errSysExit(("time(NULL)"));
    } else {
        memset(&tm, 0, sizeof(tm));
        tm.tm_year  = strtol(argv[i + 3], NULL, 10) - 1900;
        tm.tm_mon   = strtol(argv[i + 4], NULL, 10) - 1;
        tm.tm_mday  = strtol(argv[i + 5], NULL, 10);
        tm.tm_isdst = -1;
        t = mktime(&tm);
        if (t < 0) {
            errExit(("mktime: %04d/%02d/%02d",
                                         tm.tm_year, tm.tm_mon, tm.tm_mday));
        }
    }

    info.src  = argv[i + 1];
    info.dest = argv[i + 2];
    if (*info.src  != '/') goto errorExit;  /* src  must be full path */
    if (*info.dest != '/') goto errorExit;  /* dest must be full path */
    len = strlen(info.src) - 1;
    if (info.src[len] == '/') {  /* strip tail '/' */
        info.src[len] = '\0';
    }
    len = strlen(info.dest) - 1;
    if (info.dest[len] == '/') {
        info.dest[len] = '\0';
    }

    setBkupDir(t, &info);
    if (!makeJournalTree(&info)) errExit(("failed in makeJournalTree"));

    info.func = showFile;
    if (!dirwalk(info.bdir, &info)) {
        errExit(("failed in dirwalk(%s)", info.bdir));
    }
    exit(0);


errorExit:
    fprintf(stderr,
            "Source and Destination directories must be full path\n");
    exit(1);
    return 0;                   /* to make gcc happy */
}
예제 #19
0
/* Walk through directory 'path', calling dodir() for given directory
 * and dofile() for each file.
 * If recurse=1, recurse into subdirectories, calling dodir() for
 * each directory.
 */
int 
dirwalk(char *path, int recurse, PFN_dodir dodir, PFN_dodir dofile)
{    
	WIN32_FIND_DATA find_data;
	HANDLE find_handle;
	char pattern[MAXSTR];	/* orig pattern + modified pattern */
	char base[MAXSTR];
	char name[MAXSTR];
	BOOL bMore = TRUE;
	char *p;
	
	
	if (path) {
		strcpy(pattern, path);
		if (strlen(pattern) != 0)  {
			p = pattern + strlen(pattern) -1;
			if (*p == '\\')
				*p = '\0';		// truncate trailing backslash
		}
		
		strcpy(base, pattern);
		if (strchr(base, '*') != NULL) {
			// wildcard already included
			// truncate it from the base path
			if ( (p = strrchr(base, '\\')) != NULL )
				*(++p) = '\0';
		}
		else if (isalpha(pattern[0]) && 
			pattern[1]==':' && pattern[2]=='\0')  {
			strcat(pattern, "\\*");		// search entire disk
			strcat(base, "\\");
		}
		else {
			// wildcard NOT included
			// check to see if path is a directory
			find_handle = FindFirstFile(pattern, &find_data);
			if (find_handle != INVALID_HANDLE_VALUE) {
				FindClose(find_handle);
				if (find_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
					strcat(pattern, "\\*");		// yes, search files 
					strcat(base, "\\");
				}
				else {
					dofile(path);				// no, return just this file
					return 0;
				}
			}
			else
				return 1;	// path invalid
		}
	}
	else {
		base[0] = '\0';
		strcpy(pattern, "*");
	}
	
	find_handle = FindFirstFile(pattern,  &find_data);
	if (find_handle == INVALID_HANDLE_VALUE)
		return 1;
	
	while (bMore) {
		strcpy(name, base);
		strcat(name, find_data.cFileName);
		if (find_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
			if ( strcmp(find_data.cFileName, ".") && 
				strcmp(find_data.cFileName, "..") ) {
				dodir(name);
				if (recurse)
					dirwalk(name, recurse, dodir, dofile);
			}
		}
		else {
			dofile(name);
		}
		bMore = FindNextFile(find_handle, &find_data);
	}
	FindClose(find_handle);
	
	return 0;
}
예제 #20
0
BOOL make_filelist(int argc, char *argv[])
{
    char *title = NULL;
    char *dir = NULL;
    char *list = NULL;
    int i;
    g_bBatch = TRUE;	// Don't run message loop
	
    for (i=1; i<argc; i++) {
		if (strcmp(argv[i], "-title") == 0) {
			i++;
			title = argv[i];
		}
		else if (strcmp(argv[i], "-dir") == 0) {
			i++;
			dir = argv[i];
		}
		else if (strcmp(argv[i], "-list") == 0) {
			i++;
			list = argv[i];
		}
		else {
		    if ((title == NULL) || (strlen(title) == 0) ||
			(dir == NULL) || (strlen(dir) == 0) ||
			(list == NULL) || (strlen(list) == 0)) {
			message_box("Usage: setupgs -title \042GPL Ghostscript #.##\042 -dir \042gs#.##\042 -list \042filelist.txt\042 spec1 spec2 specn\n");
			return FALSE;
		    }
		    if (fList == (FILE *)NULL) {
			    if ( (fList = fopen(list, "w")) == (FILE *)NULL ) {
					message_box("Can't write list file\n");
					return FALSE;
			    }
			    fputs(title, fList);
			    fputs("\n", fList);
			    fputs(dir, fList);
			    fputs("\n", fList);
		    }
		    if (argv[i][0] == '@') {
			// Use @filename with list of files/directories
			// to avoid DOS command line limit
			FILE *f;
			char buf[MAXSTR];
			int j;
			if ( (f = fopen(&(argv[i][1]), "r")) != (FILE *)NULL) {
			    while (fgets(buf, sizeof(buf), f)) {
				// remove trailing newline and spaces
				while ( ((j = strlen(buf)-1) >= 0) &&
				    ((buf[j] == '\n') || (buf[j] == ' ')) )
				    buf[j] = '\0';
			        dirwalk(buf, TRUE, &dodir, &dofile);
			    }
			    fclose(f);
			}
			else {
				wsprintf(buf, "Can't open @ file \042%s\042",
				    &argv[i][1]);
				message_box(buf);
			}
		    }
		    else
		        dirwalk(argv[i], TRUE, &dodir, &dofile);
		}
    }
	
    if (fList != (FILE *)NULL) {
        fclose(fList);
	fList = NULL;
    }
    return TRUE;
}
예제 #21
0
int main(int argc, char **argv)
{
  if(argc==2)
    dirwalk(argv[1],(void *) (&recprint));
}
예제 #22
0
   void run(int argc, char* argv[], char* env[])
      {
      U_TRACE(5, "Application::run(%d,%p,%p)", argc, argv, env)

      UApplication::run(argc, argv, env);

      // manage options

      time_t queue_time = 0;
      UString outpath, result;
      bool include = false, bstdin = false;

      if (UApplication::isOptions())
         {
         cfg_str    =  opt['c'];
         upload     =  opt['u'];
         bstdin     = (opt['s'] == U_STRING_FROM_CONSTANT("1"));
         include    = (opt['i'] == U_STRING_FROM_CONSTANT("1"));
         outpath    =  opt['o'];
         queue_time =  opt['q'].strtol();
         }

      // manage arg operation

      UString url(argv[optind++]);

      // manage file configuration

      if (cfg_str.empty()) cfg_str = U_STRING_FROM_CONSTANT(U_SYSCONFDIR "/uclient.cfg");

      cfg.UFile::setPath(cfg_str);

      // ----------------------------------------------------------------------------------------------------------------------------------
      // uclient - configuration parameters
      // ----------------------------------------------------------------------------------------------------------------------------------
      // ENABLE_IPV6  flag to indicate use of ipv6
      // SERVER       host name or ip address for server
      // PORT         port number for the server
      //
      // PID_FILE     write pid on file indicated
      // RES_TIMEOUT  timeout for response from server
      //
      // LOG_FILE     locations   for file log
      //
      // CERT_FILE    certificate of client
      // KEY_FILE     private key of client
      // PASSWORD     password for private key of client
      // CA_FILE      locations of trusted CA certificates used in the verification
      // CA_PATH      locations of trusted CA certificates used in the verification
      // VERIFY_MODE  mode of verification (SSL_VERIFY_NONE=0, SSL_VERIFY_PEER=1, SSL_VERIFY_FAIL_IF_NO_PEER_CERT=2, SSL_VERIFY_CLIENT_ONCE=4)
      // CIPHER_SUITE cipher suite model (Intermediate=0, Modern=1, Old=2)
      //
      // FOLLOW_REDIRECTS if yes manage to automatically follow redirects from server
      // USER             if     manage to follow redirects, in response to a HTTP_UNAUTHORISED response from the HTTP server: user
      // PASSWORD_AUTH    if     manage to follow redirects, in response to a HTTP_UNAUTHORISED response from the HTTP server: password
      // ----------------------------------------------------------------------------------------------------------------------------------

      client = new UHttpClient<USSLSocket>(&cfg);

      user             = cfg[*UString::str_USER];
      password         = cfg[U_STRING_FROM_CONSTANT("PASSWORD_AUTH")];
      follow_redirects = cfg.readBoolean(U_STRING_FROM_CONSTANT("FOLLOW_REDIRECTS"));

      client->setFollowRedirects(follow_redirects);
      client->getResponseHeader()->setIgnoreCase(true);
      client->setRequestPasswordAuthentication(user, password);

      UApplication::exit_value = 1;

loop: if (upload)
         {
         UFile file(upload);

         if (client->upload(url, file)) UApplication::exit_value = 0;
         }
      else if (client->connectServer(url))
         {
         bool ok;

         if (bstdin == false) ok = client->sendRequest();
         else
            {
            UString req(U_CAPACITY);

            UServices::readEOF(STDIN_FILENO, req);

            if (req.empty()) U_ERROR("cannot read data from <stdin>");

            ok = client->sendRequest(req);
            }

         if (ok) UApplication::exit_value = 0;
         }

      result = (include ? client->getResponse()
                        : client->getContent());

      if (result)
         {
#     ifdef USE_LIBZ
         if (UStringExt::isGzip(result)) result = UStringExt::gunzip(result);
#     endif

         if (outpath) UFile::writeTo(outpath, result);
         else         (void) write(1, U_STRING_TO_PARAM(result));
         }

      if (queue_time)
         {
         UTimeVal to_sleep(queue_time / 10L);

         U_INTERNAL_ASSERT_EQUALS(UClient_Base::queue_dir, 0)

         if (result.empty() &&
             UApplication::exit_value == 1)
            {
            to_sleep.nanosleep();

            goto loop;
            }

         UFile file;
         char mask[100U];
         uint32_t i, n, pos;
         UVector<UString> vec(64);
         UString req, name, location(U_CAPACITY);

         uint32_t mask_len = u__snprintf(mask, sizeof(mask), "%.*s.*", U_STRING_TO_TRACE(client->UClient_Base::host_port));

         to_sleep.setSecond(to_sleep.getSecond() * 10L);

         U_MESSAGE("monitoring directory %.*S every %u sec - file mask: %.*S",
                        U_STRING_TO_TRACE(*UString::str_CLIENT_QUEUE_DIR), to_sleep.getSecond(), mask_len, mask);

#     ifdef USE_LIBSSL
         client->UClient_Base::setActive(false);
#     endif

         UServer_Base::timeoutMS = client->UClient_Base::timeoutMS;

         UDirWalk dirwalk(*UString::str_CLIENT_QUEUE_DIR, mask, mask_len);

         while (true)
            {
            for (i = 0, n = dirwalk.walk(vec, U_ALPHABETIC_SORT); i < n; ++i) // NB: vec is sorted by string compare...
               {
               file.setPath(vec[i]);

               // -----------------------------------------------------------------------------
               // NB: sometime there is a strange behaviour on openWRT (overlayfs) after unlink
               // -----------------------------------------------------------------------------
               // wifi-aaa.comune.fi.it.090513_132007_139 -> (overlay-whiteout)
               // -----------------------------------------------------------------------------

               req = file.getContent();

               if (req)
                  {
                  name = file.getName();
                  pos  = name.find_last_of('.');

                  U_INTERNAL_ASSERT_DIFFERS(pos, U_NOT_FOUND)

                  location.snprintf("http://%.*s", pos, name.data());

                  (void) location.shrink();

                  if (client->connectServer(location) == false ||
                      client->sendRequest(req)        == false)
                     {
                     break;
                     }
                  }

               (void) file._unlink();
               }

            vec.clear();

            if (client->isOpen()) client->close();

            to_sleep.nanosleep();
            }
         }

      client->closeLog();
      }
예제 #23
0
파일: backup_equal.c 프로젝트: jibbo/SysOp
void dirwalk(char * path1, char * path2, int indent_limit, char symb)
{
    struct dirent *dirent1, *dirent2;
    DIR *dir1, *dir2;
    struct stat stat1, stat2;
    int is_dir1, is_dir2;

    char completePath1[256];
    char completePath2[256];

    int indent_tab = 0; // serve per dare una giusta indentazione al momento della stampa in console.
    int found = 0;      // serve per vedere se il file1 è stato trovato all'interno del path2.

    // La funzione opendir apre un directory stream.
    // Restituisce un puntatore ad un oggetto di tipo DIR in caso di successo e NULL in caso di errore.
    // Inoltre posiziona lo stream sulla prima voce contenuta nella directory.
    if ((dir1 = opendir(path1)) == NULL) { 
        printf("Cannot open %s\n", path1);
        syslog(LOG_INFO, "Cannot open %s.\nTerminated.\n", path1);
        exit(EXIT_FAILURE);
    }

    // Cicla tutti i files e directory presenti all'interno del path specificato.
    // La funzione readdir legge la voce corrente nella directory, posizionandosi sulla voce successiva.
    // Restituisce un puntatore al directory stream in caso di successo e NULL in caso di errore.
    while ((dirent1 = readdir(dir1)) != NULL) {

        if (strcmp(dirent1->d_name, ".") != 0 && strcmp(dirent1->d_name, "..") != 0) {

            // Concateno il nome del file/directory al path originario per lavorare ricorsivamente sul path completo..
            // Serve per tenere traccia del path completo dove si trova il file o la directory che si sta analizzando.
            //size_t length1 = strlen(path1) + strlen(dirent1->d_name) + 1;
            //char * completePath1 = (char *) malloc(sizeof(char) * length1;
            strcpy(completePath1, path1);
            strcat(completePath1, dirent1->d_name);

            // Se si tratta di una directory aggiungo uno / tra il path e il nome della cartella
            // if ( is_dir1 ) { snprintf(completePath1, length1 + , "%s%s/", path1, dirent1->d_name); }
            // else { snprintf(completePath1, length1, "%s%s", path1, dirent1->d_name); }

            //snprintf(completePath1, length1, "%s%s", path1, dirent1->d_name);

            printf("path1: %s\n", path1);
            printf("d_name: %s\n", dirent1->d_name);
            printf("def: %s%s\n", path1, dirent1->d_name);
            printf("\n");

            //printf("analizzando %s\n\n", dirent1->d_name);

            // Setto il flag a zero per capire che finora non c'è alcun file uguale..
            found = 0;

            // Apro la directory rappresentata dal path2..
            if ((dir2 = opendir(path2)) == NULL) { 
                printf("Cannot open %s\n", path2);
                syslog(LOG_INFO, "Cannot open %s.\nTerminated.\n", path2);
                exit(EXIT_FAILURE);
            }

            // Valuto se il path1 rappresenta una directory..
            stat(completePath1, &stat1);
            is_dir1 = ((stat1.st_mode & S_IFMT) == S_IFDIR);

            // Scorro tutta la seconda directory e controllo se il file è presente
            while ((dirent2 = readdir(dir2)) != NULL) {

                // Verifico che non siano le entries di default delle directories..
                if (strcmp(dirent2->d_name, ".") != 0 && strcmp(dirent2->d_name, "..") != 0) {

                    if(strcmp(dirent1->d_name, dirent2->d_name) == 0) {

                    // Concateno il nome del file/directory al path originario per lavorare ricorsivamente sul path completo..
                    // Serve per tenere traccia del path completo dove si trova il file o la directory che si sta analizzando.
                    //size_t length2 = strlen(path2) + strlen(dirent2->d_name) + 1;
                    //char * completePath2 = (char *) malloc(sizeof(char) * length2);
                    
                    // Se si tratta di una directory aggiungo uno / tra il path e il nome della cartella
                    // if ( is_dir1 ) { snprintf(completePath1, length1 + , "%s%s/", path1, dirent1->d_name); }
                    // else { snprintf(completePath1, length1, "%s%s", path1, dirent1->d_name); }

                    //snprintf(completePath2, length2, "%s%s", path2, dirent2->d_name);

                    strcpy(completePath2, path2);
                    strcat(completePath2, dirent2->d_name);  

                    //printf("compare %s with %s\n", completePath1, completePath2);
                    //printf("\n");

                        // Setto il flag di found a 1 così riconosco che due files o directories hanno lo stesso nome..
                        found = 1;

                        // Sto visualizzando il file percorsi la prima volta..
                        if(symb == '+') {

                            printf("path2: %s\n", path2);
                            printf("d_name2: %s\n", dirent2->d_name);
                            printf("def2: %s%s\n", path2, dirent2->d_name);
                            printf("\n");
                            

                            stat(completePath2, &stat2);
                            is_dir2 = ((stat2.st_mode & S_IFMT) == S_IFDIR);

                            //printf("analizzando %s con %s \n", completePath1, completePath2 );

                            if (is_dir1 && is_dir2) {

                                //printf("cartelle\n");

                                // Se sono cartelle aggiungo uno / al path
                                strcat(completePath1, "/");
                                strcat(completePath2, "/");

                                if( are_equals_directories(completePath1, completePath2) != 1) {

                                    // Cartelle con contenuto diverso..
                                    for(indent_tab = 0; indent_tab < indent_limit; indent_tab++) { printf("  "); }
                                    printf ("Differences between folders: %s - %s\n", completePath1, completePath2);

                                    // Procedo in maniera ricorsiva sulle sub-directory aventi lo stesso nome in entrambi i path..
                                    dirwalk(completePath1, completePath2, indent_limit + 1, '+');
                                    dirwalk(completePath2, completePath1, indent_limit + 1, '-');
                                    printf("------------------------------\n");
                                }

                            } else {
                                diffBetweenFiles(completePath1, completePath2, indent_limit);
                            }

                            //free(completePath2);
                        }
                    }
                }
            }

            // A seconda che il file sia presente nel path2 stampo una + o -
            if(!found) {
                for(indent_tab = 0; indent_tab < indent_limit; indent_tab++) { printf("  "); }
                    printf ("%c %s\n", symb, dirent1->d_name);
            }

            //free(completePath1);
            closedir(dir2);
        }
    }

    // Chiude il directory stream.
    // La funzione restituisce 0 in caso di successo e -1 altrimenti, 
    closedir(dir1);
}
예제 #24
0
파일: backup_equal.c 프로젝트: jibbo/SysOp
int main (int argc, char **argv) {

    // Start with project
    // .....................................................................................

    // Apro il file di log..
    openlog(argv[0], LOG_CONS || LOG_PID, LOG_LOCAL0);
    syslog(LOG_INFO, "Utility started: %s", argv[0]);
    syslog(LOG_INFO, "\nFirst path passed: %s", argv[1]);
    syslog(LOG_INFO, "\nSecond path passsed: %s", argv[2]);

    // Dichiaro due strutture di tipo stat che mi serviranno per estrarre informazioni relative ai due percorsi dei files..
    struct stat stbuf1;
    struct stat stbuf2;

    // Gestisce la tabulazione per una stampa a console ordinata..
    int indent = 1;

    // Valuto se i due percorsi hanno particolari restrizioni di accesso..
    // In caso di errore esco e aggiungo un nuovo messaggio al file di log..
    int access_err1 = (stat(argv[1], &stbuf1) == -1);
    int access_err2 = (stat(argv[2], &stbuf2) == -1);
    if ( access_err1 ) {
        printf("Error: can't access %s\n", argv[1]);
        syslog(LOG_ERR, "Error: can't access %s", argv[1]);
        exit(EXIT_FAILURE);
    }
    if ( access_err2) {
        printf("Error: can't access %s\n", argv[2]);
        syslog(LOG_ERR, "Error: can't access %s", argv[2]);
        exit(EXIT_FAILURE);
    }

    // Valuto se i due percorsi sono delle directories..
    int is_dir_1 = ((stbuf1.st_mode & S_IFMT) == S_IFDIR);
    int is_dir_2 = ((stbuf2.st_mode & S_IFMT) == S_IFDIR);
    if(is_dir_1 && is_dir_2) {

        // I due percorsi rappresentano entrambi due directories..
        syslog(LOG_INFO, "Both paths are directories.");

        // Differences from path1 to path2..
        dirwalk(argv[1], argv[2], indent, '+');

        // Differences from path2 to path1..
        dirwalk(argv[2], argv[1], indent, '-');
    }
    else if(!is_dir_1 && !is_dir_2) {

        // I due percorsi rappresentano entrambi due files..
        syslog(LOG_INFO, "Both paths are files.");
        diffBetweenFiles(argv[1], argv[2], indent);
    }
    else {

        // I due percorsi non possono essere comparati..
        syslog(LOG_INFO, "Paths cannot be compared. Terminated.");
        printf("You cannot compare two different kind of files (one directory one file)!");
        exit(EXIT_FAILURE);
    }

    // Termino con successo..
    syslog(LOG_INFO, "Exit success. Terminated.");
    printf("\n");
    exit(EXIT_SUCCESS);
}
예제 #25
0
/* This is a recursive function.
 */
int
dirwalk (char* dir, bkupInfo* info)
{
    DIR*           pDir;
    struct dirent* pEnt;
    struct stat    stbuf;
    char*          newdir;      /* new (next) source directory */
    char*          bkupdir;     /* backup directory */


    assert(dir);
    assert(info);
    assert(info->bdir);
    assert(info->func);

    pDir = opendir(dir);
    if (!pDir) {
        errSysRet(("opendir(%s)", dir));
        return 0;
    }
    if (chdir(dir)) {
        errSysRet(("chdir(%s)", dir));
        return 0;
    }
    for (pEnt = readdir(pDir); pEnt; pEnt = readdir(pDir)) {
        if (lstat(pEnt->d_name, &stbuf)) {
            errSysRet(("stat(%s)", pEnt->d_name));
            continue;
        }
        switch (stbuf.st_mode & S_IFMT) {
        case S_IFSOCK:
            printf("%s/%s: socket ignored\n", dir, pEnt->d_name);
            break;
        case S_IFBLK:
            printf("%s/%s: block device ignored\n", dir, pEnt->d_name);
            break;
        case S_IFCHR:
            printf("%s/%s: character device ignored\n", dir, pEnt->d_name);
            break;
        case S_IFIFO:
            printf("%s/%s: fifo ignored\n", dir, pEnt->d_name);
            break;
        case S_IFDIR:
            if (strcmp(".", pEnt->d_name) == 0) {
                break;
            }
            if (strcmp("..", pEnt->d_name) == 0) {
                break;
            }
            bkupdir = malloc(info->blen +
                             strlen(dir) + strlen(pEnt->d_name) + 3);
            if (!bkupdir) {
                errSysRet(("%s/%s/%s: can't alloc memory",
                           info->bdir, dir, pEnt->d_name));
                continue;
            }
            strcpy(bkupdir, info->bdir);
            if (*dir != '/') {
                strcat(bkupdir, "/");
            }
            strcat(bkupdir, dir);
            strcat(bkupdir, "/");
            strcat(bkupdir, pEnt->d_name);
            newdir = bkupdir + info->blen;
            if (!newDirectory(bkupdir, &stbuf, info)) {
                errRet(("newDirectory(%s, 0x%08x)", bkupdir, stbuf.st_mode));
                continue;
            }
            dirwalk(newdir, info); /* recursion */
            free(bkupdir);
            if (chdir(dir)) {
                errSysRet(("chdir(%s)", dir));
                return 0;
            }
            break;
        case S_IFLNK:
        case S_IFREG:
            info->ctime = stbuf.st_ctime;
            info->mtime = stbuf.st_mtime;
            info->stbuf = &stbuf;
            (*info->func)(dir, pEnt->d_name, info);
            break;
        default:
            errRet(("%s/%s: unknown type (0x%x) ignored\n",
                  dir, pEnt->d_name, stbuf.st_mode & S_IFMT));
            break;
        }
    }
    if (closedir(pDir)) {
        errSysRet(("closedir(%d)", dir));
    }
    return 1;
}