Beispiel #1
0
int File_copyTo( const IFile* self, const IPath* targetPath, int force )
{
	bool status = 0;

	char* target = NULL;
	IFile* target_file = NULL;
	IDirectory* target_dir = new_Directory_path( targetPath );
	if ( Directory_exists( target_dir ) )
	{
		target = CharString_cat3( Path_getCommon( targetPath ), "/", Path_getBasename( self->path ) );
	} else {
		target = CharString_copy( Path_getCommon( targetPath ) );
	}

	target_file = new_File( target );
	if ( !File_exists( target_file ) || force )
	{
		if ( File_open( target_file, "w" ) )
		{
			byte buffer[256];
			int read;
		
			while ( (read = File_read( self, buffer, 256 )) )
			{
				File_write( target_file, buffer, read );
				status = 1;
			}
			if ( !status )
			{
				fprintf( stdout, "File.c::copyTo: could not copy data\n" );
			}
		}
		File_close( target_file );
	}		
	free_Directory( target_dir );
	free_File( target_file );
	free_CharString( target );	

	return status;
}
Beispiel #2
0
Errors Misc_executeCommand(const char        *commandTemplate,
                           const TextMacro   macros[],
                           uint              macroCount,
                           ExecuteIOFunction stdoutExecuteIOFunction,
                           ExecuteIOFunction stderrExecuteIOFunction,
                           void              *executeIOUserData
                          )
{
  Errors          error;
  String          commandLine;
  StringTokenizer stringTokenizer;
  String          token;
  String          command;
  StringList      argumentList;
  const char      *path;
  String          fileName;
  bool            foundFlag;
  char const      **arguments;
  int             pipeStdin[2],pipeStdout[2],pipeStderr[2];
  int             pid;
  StringNode      *stringNode;
  uint            n,z;
  int             status;
  bool            sleepFlag;
  String          stdoutLine,stderrLine;
  int             exitcode;
  int             terminateSignal;

  error = ERROR_NONE;
  if (commandTemplate != NULL)
  {
    commandLine = String_new();
    command     = File_newFileName();
    StringList_init(&argumentList);

    // expand command line
    Misc_expandMacros(commandLine,commandTemplate,macros,macroCount);
    printInfo(3,"Execute command '%s'...",String_cString(commandLine));

    // parse command
    String_initTokenizer(&stringTokenizer,commandLine,STRING_BEGIN,STRING_WHITE_SPACES,STRING_QUOTES,FALSE);
    if (!String_getNextToken(&stringTokenizer,&token,NULL))
    {
      String_doneTokenizer(&stringTokenizer);
      StringList_done(&argumentList);
      String_delete(command);
      String_delete(commandLine);
      return ERRORX_(PARSE_COMMAND,0,String_cString(commandLine));
    }
    File_setFileName(command,token);

    // parse arguments
    while (String_getNextToken(&stringTokenizer,&token,NULL))
    {
      StringList_append(&argumentList,token);
    }
    String_doneTokenizer(&stringTokenizer);

    // find command in PATH
    path = getenv("PATH");
    if (path != NULL)
    {
      fileName  = File_newFileName();
      foundFlag = FALSE;
      String_initTokenizerCString(&stringTokenizer,path,":","",FALSE);
      while (String_getNextToken(&stringTokenizer,&token,NULL) && !foundFlag)
      {
        File_setFileName(fileName,token);
        File_appendFileName(fileName,command);
        if (File_exists(fileName))
        {
          File_setFileName(command,fileName);
          foundFlag = TRUE;
        }
      }
      String_doneTokenizer(&stringTokenizer);
      File_deleteFileName(fileName);
    }

#if 0
fprintf(stderr,"%s,%d: command %s\n",__FILE__,__LINE__,String_cString(command));
stringNode = argumentList.head;
while (stringNode != NULL)
{
fprintf(stderr,"%s,%d: argument %s\n",__FILE__,__LINE__,String_cString(stringNode->string));
stringNode = stringNode->next;
}
#endif /* 0 */

    #if defined(HAVE_PIPE) && defined(HAVE_FORK) && defined(HAVE_WAITPID)
#if 1
      // create i/o pipes
      if (pipe(pipeStdin) != 0)
      {
        error = ERRORX_(IO_REDIRECT_FAIL,errno,String_cString(commandLine));
        StringList_done(&argumentList);
        String_delete(command);
        String_delete(commandLine);
        return error;
      }
      if (pipe(pipeStdout) != 0)
      {
        error = ERRORX_(IO_REDIRECT_FAIL,errno,String_cString(commandLine));
        close(pipeStdin[0]);
        close(pipeStdin[1]);
        StringList_done(&argumentList);
        String_delete(command);
        String_delete(commandLine);
        return error;
      }
      if (pipe(pipeStderr) != 0)
      {
        error = ERRORX_(IO_REDIRECT_FAIL,errno,String_cString(commandLine));
        close(pipeStdout[0]);
        close(pipeStdout[1]);
        close(pipeStdin[0]);
        close(pipeStdin[1]);
        StringList_done(&argumentList);
        String_delete(command);
        String_delete(commandLine);
        return error;
      }

      // do fork to start separated process
      pid = fork();
      if      (pid == 0)
      {
        // close stdin, stdout, and stderr and reassign them to the pipes
        close(STDERR_FILENO);
        close(STDOUT_FILENO);
        close(STDIN_FILENO);

        // redirect stdin/stdout/stderr to pipe
        dup2(pipeStdin[0],STDIN_FILENO);
        dup2(pipeStdout[1],STDOUT_FILENO);
        dup2(pipeStderr[1],STDERR_FILENO);

        /* close unused pipe handles (the pipes are duplicated by fork(), thus
           there are two open ends of the pipes)
        */
        close(pipeStderr[0]);
        close(pipeStdout[0]);
        close(pipeStdin[1]);

        // execute of external program
        n = 1+StringList_count(&argumentList)+1;
        arguments = (char const**)malloc(n*sizeof(char*));
        if (arguments == NULL)
        {
          HALT_INSUFFICIENT_MEMORY();
        }
        z = 0;
        arguments[z] = String_cString(command); z++;
        stringNode = argumentList.head;
        while (stringNode != NULL)
        {
          assert(z < n);
          arguments[z] = String_cString(stringNode->string); z++;
          stringNode = stringNode->next;
        }
        assert(z < n);
        arguments[z] = NULL; z++;
        execvp(String_cString(command),(char**)arguments);

        // in case exec() fail, return a default exitcode
        HALT_INTERNAL_ERROR("execvp() returned");
      }
      else if (pid < 0)
      {
        error = ERRORX_(EXEC_FAIL,errno,String_cString(commandLine));
        printInfo(3,"FAIL!\n");

        close(pipeStderr[0]);
        close(pipeStderr[1]);
        close(pipeStdout[0]);
        close(pipeStdout[1]);
        close(pipeStdin[0]);
        close(pipeStdin[1]);
        StringList_done(&argumentList);
        String_delete(command);
        String_delete(commandLine);
        return error;
      }

      // close unused pipe handles (the pipe is duplicated by fork(), thus there are two open ends of the pipe)
      close(pipeStderr[1]);
      close(pipeStdout[1]);
      close(pipeStdin[0]);
#else /* 0 */
error = ERROR_NONE;
#endif /* 0 */

      // wait until process terminate and read stdout/stderr
      stdoutLine = String_new();
      stderrLine = String_new();
      status = 0;
      while ((waitpid(pid,&status,WNOHANG) == 0) || (!WIFEXITED(status) && !WIFSIGNALED(status)))
      {
        sleepFlag = TRUE;

        if (readProcessIO(pipeStdout[0],stdoutLine))
        {
          if (stdoutExecuteIOFunction != NULL) stdoutExecuteIOFunction(executeIOUserData,stdoutLine);
          String_clear(stdoutLine);
          sleepFlag = FALSE;
        }
        if (readProcessIO(pipeStderr[0],stderrLine))
        {
          if (stderrExecuteIOFunction != NULL) stderrExecuteIOFunction(executeIOUserData,stderrLine);
          String_clear(stderrLine);
          sleepFlag = FALSE;
        }

        if (sleepFlag)
        {
          Misc_udelay(500LL*1000LL);
        }
      }
      while (readProcessIO(pipeStdout[0],stdoutLine))
      {
        if (stdoutExecuteIOFunction != NULL) stdoutExecuteIOFunction(executeIOUserData,stdoutLine);
        String_clear(stdoutLine);
      }
      while (readProcessIO(pipeStderr[0],stderrLine))
      {
        if (stderrExecuteIOFunction != NULL) stderrExecuteIOFunction(executeIOUserData,stderrLine);
        String_clear(stderrLine);
      }
      String_delete(stderrLine);
      String_delete(stdoutLine);

      // close i/o
      close(pipeStderr[0]);
      close(pipeStdout[0]);
      close(pipeStdin[1]);

      // check exit code
      exitcode = -1;
      if      (WIFEXITED(status))
      {
        exitcode = WEXITSTATUS(status);
        printInfo(3,"ok (exitcode %d)\n",exitcode);
        if (exitcode != 0)
        {
          error = ERRORX_(EXEC_FAIL,exitcode,String_cString(commandLine));
          StringList_done(&argumentList);
          String_delete(command);
          String_delete(commandLine);
          return error;
        }
      }
      else if (WIFSIGNALED(status))
      {
        terminateSignal = WTERMSIG(status);
        error = ERRORX_(EXEC_FAIL,terminateSignal,String_cString(commandLine));
        printInfo(3,"FAIL (signal %d)\n",terminateSignal);
        StringList_done(&argumentList);
        String_delete(command);
        String_delete(commandLine);
        return error;
      }
      else
      {
        printInfo(3,"ok (unknown exit)\n");
      }
    #elif defined(WIN32)
#if 0
HANDLE hOutputReadTmp,hOutputRead,hOutputWrite;
      HANDLE hInputWriteTmp,hInputRead,hInputWrite;
      HANDLE hErrorWrite;
      HANDLE hThread;
      DWORD ThreadId;
      SECURITY_ATTRIBUTES sa;


      // Set up the security attributes struct.
      sa.nLength= sizeof(SECURITY_ATTRIBUTES);
      sa.lpSecurityDescriptor = NULL;
      sa.bInheritHandle = TRUE;


      // Create the child output pipe.
      if (!CreatePipe(&hOutputReadTmp,&hOutputWrite,&sa,0))
         DisplayError("CreatePipe");


      // Create a duplicate of the output write handle for the std error
      // write handle. This is necessary in case the child application
      // closes one of its std output handles.
      if (!DuplicateHandle(GetCurrentProcess(),hOutputWrite,
                           GetCurrentProcess(),&hErrorWrite,0,
                           TRUE,DUPLICATE_SAME_ACCESS))
         DisplayError("DuplicateHandle");


      // Create the child input pipe.
      if (!CreatePipe(&hInputRead,&hInputWriteTmp,&sa,0))
         DisplayError("CreatePipe");


      // Create new output read handle and the input write handles. Set
      // the Properties to FALSE. Otherwise, the child inherits the
      // properties and, as a result, non-closeable handles to the pipes
      // are created.
      if (!DuplicateHandle(GetCurrentProcess(),hOutputReadTmp,
                           GetCurrentProcess(),
                           &hOutputRead, // Address of new handle.
                           0,FALSE, // Make it uninheritable.
                           DUPLICATE_SAME_ACCESS))
         DisplayError("DupliateHandle");

      if (!DuplicateHandle(GetCurrentProcess(),hInputWriteTmp,
                           GetCurrentProcess(),
                           &hInputWrite, // Address of new handle.
                           0,FALSE, // Make it uninheritable.
                           DUPLICATE_SAME_ACCESS))
      DisplayError("DupliateHandle");


      // Close inheritable copies of the handles you do not want to be
      // inherited.
      if (!CloseHandle(hOutputReadTmp)) DisplayError("CloseHandle");
      if (!CloseHandle(hInputWriteTmp)) DisplayError("CloseHandle");


      // Get std input handle so you can close it and force the ReadFile to
      // fail when you want the input thread to exit.
      if ( (hStdIn = GetStdHandle(STD_INPUT_HANDLE)) ==
                                                INVALID_HANDLE_VALUE )
         DisplayError("GetStdHandle");

      PrepAndLaunchRedirectedChild(hOutputWrite,hInputRead,hErrorWrite);


      // Close pipe handles (do not continue to modify the parent).
      // You need to make sure that no handles to the write end of the
      // output pipe are maintained in this process or else the pipe will
      // not close when the child process exits and the ReadFile will hang.
      if (!CloseHandle(hOutputWrite)) DisplayError("CloseHandle");
      if (!CloseHandle(hInputRead )) DisplayError("CloseHandle");
      if (!CloseHandle(hErrorWrite)) DisplayError("CloseHandle");


      // Launch the thread that gets the input and sends it to the child.
      hThread = CreateThread(NULL,0,GetAndSendInputThread,
                              (LPVOID)hInputWrite,0,&ThreadId);
      if (hThread == NULL) DisplayError("CreateThread");


      // Read the child's output.
      ReadAndHandleOutput(hOutputRead);
      // Redirection is complete


      // Force the read on the input to return by closing the stdin handle.
      if (!CloseHandle(hStdIn)) DisplayError("CloseHandle");


      // Tell the thread to exit and wait for thread to die.
      bRunThread = FALSE;

      if (WaitForSingleObject(hThread,INFINITE) == WAIT_FAILED)
         DisplayError("WaitForSingleObject");

      if (!CloseHandle(hOutputRead)) DisplayError("CloseHandle");
      if (!CloseHandle(hInputWrite)) DisplayError("CloseHandle");
#endif
    #else /* not defined(HAVE_PIPE) && defined(HAVE_FORK) && defined(HAVE_WAITPID) || WIN32 */
      #error pipe()/fork()/waitpid() not available nor Win32 system!
    #endif /* defined(HAVE_PIPE) && defined(HAVE_FORK) && defined(HAVE_WAITPID) || WIN32 */

    // free resources
    StringList_done(&argumentList);
    String_delete(command);
    String_delete(commandLine);
  }

  return error;
}
Beispiel #3
0
// Determine which directory should store the user's configuration.
//
// For most Unix and Windows platforms:
// If a config file already exists in program_dir, it will return it in priority
// (Useful for development, and possibly for upgrading from DOS version)
// If the standard directory doesn't exist yet, this function will attempt 
// to create it ($(HOME)/.grafx2, or %APPDATA%\GrafX2)
// If it cannot be created, this function will return the executable's
// own directory.
// IN: The directory containing the executable
// OUT: Write into config_dir. Trailing / or \ is kept.
void Set_config_directory(const char * program_dir, char * config_dir)
{
  // AmigaOS4
  #if defined(__amigaos4__) || defined(__AROS__)
    strcpy(config_dir,"PROGDIR:");
  // GP2X
  #elif defined(__GP2X__) || defined(__WIZ__) || defined(__CAANOO__)
    // On the GP2X, the program is installed to the sdcard, and we don't want to mess with the system tree which is
    // on an internal flash chip. So, keep these settings locals.
    strcpy(config_dir,program_dir);
  #elif defined(__MINT__)  
    strcpy(config_dir,program_dir);
  #else
    char filename[MAX_PATH_CHARACTERS];

    // In priority: check root directory
    strcpy(config_dir, program_dir);
    // On all the remaining targets except OSX, the executable is in ./bin
    #if !defined(__macosx__)
    strcat(config_dir, "../");
    #endif
    strcpy(filename, config_dir);
    strcat(filename, CONFIG_FILENAME);

    if (!File_exists(filename))
    {
      char *config_parent_dir;
      #if defined(__WIN32__)
        // "%APPDATA%\GrafX2"
        const char* Config_SubDir = "GrafX2";
        config_parent_dir = getenv("APPDATA");
      #elif defined(__BEOS__) || defined(__HAIKU__)
        // "~/.grafx2", the BeOS way
        const char* Config_SubDir = ".grafx2";
        config_parent_dir = getenv("$HOME");
      #elif defined(__macosx__)
        // "~/Library/Preferences/com.googlecode.grafx2"
        const char* Config_SubDir = "Library/Preferences/com.googlecode.grafx2";
        config_parent_dir = getenv("HOME");
      #elif defined(__MINT__)
         const char* Config_SubDir = "";
         printf("GFX2.CFG not found in %s\n",filename);
         strcpy(config_parent_dir, config_dir);
      #else
        // "~/.grafx2"      
        const char* Config_SubDir = ".grafx2";
        config_parent_dir = getenv("HOME");
      #endif

      if (config_parent_dir && config_parent_dir[0]!='\0')
      {
        int size = strlen(config_parent_dir);
        strcpy(config_dir, config_parent_dir);
        if (config_parent_dir[size-1] != '\\' && config_parent_dir[size-1] != '/')
        {
          strcat(config_dir,PATH_SEPARATOR);
        }
        strcat(config_dir,Config_SubDir);
        if (Directory_exists(config_dir))
        {
          // Répertoire trouvé, ok
          strcat(config_dir,PATH_SEPARATOR);
        }
        else
        {
          // Tentative de création
          if (!Create_ConfigDirectory(config_dir)) 
          {
            // Réussi
            strcat(config_dir,PATH_SEPARATOR);
          }
          else
          {
            // Echec: on se rabat sur le repertoire de l'executable.
            strcpy(config_dir,program_dir);
            #if defined(__macosx__)
              strcat(config_dir, "../");
            #endif
          }
        }
      }
    }
  #endif
}
Errors Command_compare(StringList                      *archiveFileNameList,
                       EntryList                       *includeEntryList,
                       PatternList                     *excludePatternList,
                       JobOptions                      *jobOptions,
                       ArchiveGetCryptPasswordFunction archiveGetCryptPasswordFunction,
                       void                            *archiveGetCryptPasswordUserData
                      )
{
  byte              *archiveBuffer,*buffer;
  FragmentList      fragmentList;
  String            archiveFileName;
  Errors            failError;
  Errors            error;
  ArchiveInfo       archiveInfo;
  ArchiveFileInfo   archiveFileInfo;
  ArchiveEntryTypes archiveEntryType;
  FragmentNode      *fragmentNode;

  assert(archiveFileNameList != NULL);
  assert(includeEntryList != NULL);
  assert(excludePatternList != NULL);
  assert(jobOptions != NULL);

  /* allocate resources */
  archiveBuffer = (byte*)malloc(BUFFER_SIZE);
  if (archiveBuffer == NULL)
  {
    HALT_INSUFFICIENT_MEMORY();
  }
  buffer = malloc(BUFFER_SIZE);
  if (buffer == NULL)
  {
    free(archiveBuffer);
    HALT_INSUFFICIENT_MEMORY();
  }
  FragmentList_init(&fragmentList);
  archiveFileName = String_new();

  failError = ERROR_NONE;
  while (   !StringList_empty(archiveFileNameList)
         && (failError == ERROR_NONE)
        )
  {
    StringList_getFirst(archiveFileNameList,archiveFileName);
    printInfo(1,"Comparing archive '%s':\n",String_cString(archiveFileName));

    /* open archive */
    error = Archive_open(&archiveInfo,
                         archiveFileName,
                         jobOptions,
                         archiveGetCryptPasswordFunction,
                         archiveGetCryptPasswordUserData
                        );
    if (error != ERROR_NONE)
    {
      printError("Cannot open archive file '%s' (error: %s)!\n",
                 String_cString(archiveFileName),
                 Errors_getText(error)
                );
      if (failError == ERROR_NONE) failError = error;
      continue;
    }

    /* read files */
    while (   !Archive_eof(&archiveInfo)
           && (failError == ERROR_NONE)
          )
    {
      /* get next archive entry type */
      error = Archive_getNextArchiveEntryType(&archiveInfo,
                                              &archiveFileInfo,
                                              &archiveEntryType
                                             );
      if (error != ERROR_NONE)
      {
        printError("Cannot not read next entry in archive '%s' (error: %s)!\n",
                   String_cString(archiveFileName),
                   Errors_getText(error)
                  );
        if (failError == ERROR_NONE) failError = error;
        break;
      }

      switch (archiveEntryType)
      {
        case ARCHIVE_ENTRY_TYPE_FILE:
          {
            String       fileName;
            FileInfo     fileInfo;
            uint64       fragmentOffset,fragmentSize;
            FragmentNode *fragmentNode;
//            FileInfo   localFileInfo;
            FileHandle   fileHandle;
            bool         equalFlag;
            uint64       length;
            ulong        n;
            ulong        diffIndex;

            /* read file */
            fileName = String_new();
            error = Archive_readFileEntry(&archiveInfo,
                                          &archiveFileInfo,
                                          NULL,
                                          NULL,
                                          NULL,
                                          fileName,
                                          &fileInfo,
                                          &fragmentOffset,
                                          &fragmentSize
                                         );
            if (error != ERROR_NONE)
            {
              printError("Cannot not read 'file' content of archive '%s' (error: %s)!\n",
                         String_cString(archiveFileName),
                         Errors_getText(error)
                        );
              String_delete(fileName);
              if (failError == ERROR_NONE) failError = error;
              break;
            }

            if (   (List_empty(includeEntryList) || EntryList_match(includeEntryList,fileName,PATTERN_MATCH_MODE_EXACT))
                && !PatternList_match(excludePatternList,fileName,PATTERN_MATCH_MODE_EXACT)
               )
            {
              printInfo(2,"  Compare file '%s'...",String_cString(fileName));

              /* check file */
              if (!File_exists(fileName))
              {
                printInfo(2,"FAIL!\n");
                printError("File '%s' not found!\n",String_cString(fileName));
                Archive_closeEntry(&archiveFileInfo);
                String_delete(fileName);
                if (jobOptions->stopOnErrorFlag)
                {
                  failError = ERROR_FILE_NOT_FOUND;
                }
                break;
              }
              if (File_getType(fileName) != FILE_TYPE_FILE)
              {
                printInfo(2,"FAIL!\n");
                printError("'%s' is not a file!\n",String_cString(fileName));
                Archive_closeEntry(&archiveFileInfo);
                String_delete(fileName);
                if (jobOptions->stopOnErrorFlag)
                {
                  failError = ERROR_WRONG_FILE_TYPE;
                }
                break;
              }

              /* get file fragment list */
              fragmentNode = FragmentList_find(&fragmentList,fileName);
              if (fragmentNode == NULL)
              {
                fragmentNode = FragmentList_add(&fragmentList,fileName,fileInfo.size);
              }
//FragmentList_print(fragmentNode,String_cString(fileName));

              /* open file */
              error = File_open(&fileHandle,fileName,FILE_OPENMODE_READ);
              if (error != ERROR_NONE)
              {
                printInfo(2,"FAIL!\n");
                printError("Cannot open file '%s' (error: %s)\n",
                           String_cString(fileName),
                           Errors_getText(error)
                          );
                Archive_closeEntry(&archiveFileInfo);
                String_delete(fileName);
                if (jobOptions->stopOnErrorFlag)
                {
                  failError = error;
                }
                continue;
              }

              /* check file size */
              if (fileInfo.size != File_getSize(&fileHandle))
              {
                printInfo(2,"FAIL!\n");
                printError("'%s' differ in size: expected %lld bytes, found %lld bytes\n",
                           String_cString(fileName),
                           fileInfo.size,
                           File_getSize(&fileHandle)
                          );
                File_close(&fileHandle);
                Archive_closeEntry(&archiveFileInfo);
                String_delete(fileName);
                if (jobOptions->stopOnErrorFlag)
                {
                  failError = ERROR_FILES_DIFFER;
                }
                continue;
              }

              /* check file content */
              error = File_seek(&fileHandle,fragmentOffset);
              if (error != ERROR_NONE)
              {
                printInfo(2,"FAIL!\n");
                printError("Cannot read file '%s' (error: %s)\n",
                           String_cString(fileName),
                           Errors_getText(error)
                          );
                File_close(&fileHandle);
                Archive_closeEntry(&archiveFileInfo);
                String_delete(fileName);
                if (jobOptions->stopOnErrorFlag)
                {
                  failError = error;
                }
                continue;
              }
              length    = 0;
              equalFlag = TRUE;
              diffIndex = 0;
              while ((length < fragmentSize) && equalFlag)
              {
                n = MIN(fragmentSize-length,BUFFER_SIZE);

                /* read archive, file */
                error = Archive_readData(&archiveFileInfo,archiveBuffer,n);
                if (error != ERROR_NONE)
                {
                  printInfo(2,"FAIL!\n");
                  printError("Cannot not read content of archive '%s' (error: %s)!\n",
                             String_cString(archiveFileName),
                             Errors_getText(error)
                            );
                  if (failError == ERROR_NONE) failError = error;
                  break;
                }
                error = File_read(&fileHandle,buffer,n,NULL);
                if (error != ERROR_NONE)
                {
                  printInfo(2,"FAIL!\n");
                  printError("Cannot read file '%s' (error: %s)\n",
                             String_cString(fileName),
                             Errors_getText(error)
                            );
                  if (jobOptions->stopOnErrorFlag)
                  {
                    failError = error;
                  }
                  break;
                }

                /* compare */
                diffIndex = compare(archiveBuffer,buffer,n);
                equalFlag = (diffIndex >= n);
                if (!equalFlag)
                {
                  printInfo(2,"FAIL!\n");
                  printError("'%s' differ at offset %llu\n",
                             String_cString(fileName),
                             fragmentOffset+length+(uint64)diffIndex
                            );
                  if (jobOptions->stopOnErrorFlag)
                  {
                    failError = ERROR_FILES_DIFFER;
                  }
                  break;
                }

                length += n;
              }
              File_close(&fileHandle);
              if (failError != ERROR_NONE)
              {
                Archive_closeEntry(&archiveFileInfo);
                String_delete(fileName);
                continue;
              }

#if 0
              /* get local file info */
              /* check file time, permissions, file owner/group */
#endif /* 0 */
              printInfo(2,"ok\n");

              /* add fragment to file fragment list */
              FragmentList_addEntry(fragmentNode,fragmentOffset,fragmentSize);

              /* discard fragment list if file is complete */
              if (FragmentList_checkEntryComplete(fragmentNode))
              {
                FragmentList_remove(&fragmentList,fragmentNode);
              }

              /* free resources */
            }
            else
            {
              /* skip */
              printInfo(3,"  Compare '%s'...skipped\n",String_cString(fileName));
            }

            /* close archive file, free resources */
            Archive_closeEntry(&archiveFileInfo);
            String_delete(fileName);
          }
          break;
        case ARCHIVE_ENTRY_TYPE_IMAGE:
          {
            String       imageName;
            DeviceInfo   deviceInfo;
            uint64       blockOffset,blockCount;
            FragmentNode *fragmentNode;
            DeviceHandle deviceHandle;
            bool         equalFlag;
            uint64       block;
            ulong        bufferBlockCount;
            ulong        diffIndex;

            /* read image */
            imageName = String_new();
            error = Archive_readImageEntry(&archiveInfo,
                                           &archiveFileInfo,
                                           NULL,
                                           NULL,
                                           NULL,
                                           imageName,
                                           &deviceInfo,
                                           &blockOffset,
                                           &blockCount
                                          );
            if (error != ERROR_NONE)
            {
              printError("Cannot not read 'image' content of archive '%s' (error: %s)!\n",
                         String_cString(archiveFileName),
                         Errors_getText(error)
                        );
              String_delete(imageName);
              if (failError == ERROR_NONE) failError = error;
              break;
            }

            if (   (List_empty(includeEntryList) || EntryList_match(includeEntryList,imageName,PATTERN_MATCH_MODE_EXACT))
                && !PatternList_match(excludePatternList,imageName,PATTERN_MATCH_MODE_EXACT)
               )
            {
              printInfo(2,"  Compare image '%s'...",String_cString(imageName));

              /* check if device exists */
              if (!File_exists(imageName))
              {
                printInfo(2,"FAIL!\n");
                printError("Device '%s' not found!\n",String_cString(imageName));
                Archive_closeEntry(&archiveFileInfo);
                String_delete(imageName);
                if (jobOptions->stopOnErrorFlag)
                {
                  failError = ERROR_FILE_NOT_FOUND;
                }
                break;
              }

              /* get image fragment list */
              fragmentNode = FragmentList_find(&fragmentList,imageName);
              if (fragmentNode == NULL)
              {
                fragmentNode = FragmentList_add(&fragmentList,imageName,deviceInfo.size);
              }

              /* open device */
              error = Device_open(&deviceHandle,imageName,DEVICE_OPENMODE_READ);
              if (error != ERROR_NONE)
              {
                printInfo(2,"FAIL!\n");
                printError("Cannot open file '%s' (error: %s)\n",
                           String_cString(imageName),
                           Errors_getText(error)
                          );
                Archive_closeEntry(&archiveFileInfo);
                String_delete(imageName);
                if (jobOptions->stopOnErrorFlag)
                {
                  failError = error;
                }
                continue;
              }

              /* check image size */
              if (deviceInfo.size != Device_getSize(&deviceHandle))
              {
                printInfo(2,"FAIL!\n");
                printError("'%s' differ in size: expected %lld bytes, found %lld bytes\n",
                           String_cString(imageName),
                           deviceInfo.size,
                           Device_getSize(&deviceHandle)
                          );
                Device_close(&deviceHandle);
                Archive_closeEntry(&archiveFileInfo);
                String_delete(imageName);
                if (jobOptions->stopOnErrorFlag)
                {
                  failError = ERROR_FILES_DIFFER;
                }
                continue;
              }

              /* check image content */
              error = Device_seek(&deviceHandle,blockOffset*(uint64)deviceInfo.blockSize);
              if (error != ERROR_NONE)
              {
                printInfo(2,"FAIL!\n");
                printError("Cannot read file '%s' (error: %s)\n",
                           String_cString(imageName),
                           Errors_getText(error)
                          );
                Device_close(&deviceHandle);
                Archive_closeEntry(&archiveFileInfo);
                String_delete(imageName);
                if (jobOptions->stopOnErrorFlag)
                {
                  failError = error;
                }
                continue;
              }
              block     = 0LL;
              equalFlag = TRUE;
              diffIndex = 0;
              while ((block < blockCount) && equalFlag)
              {
                assert(deviceInfo.blockSize > 0);
                bufferBlockCount = MIN(blockCount-block,BUFFER_SIZE/deviceInfo.blockSize);

                /* read archive, file */
                error = Archive_readData(&archiveFileInfo,archiveBuffer,bufferBlockCount*deviceInfo.blockSize);
                if (error != ERROR_NONE)
                {
                  printInfo(2,"FAIL!\n");
                  printError("Cannot not read content of archive '%s' (error: %s)!\n",
                             String_cString(archiveFileName),
                             Errors_getText(error)
                            );
                  if (failError == ERROR_NONE) failError = error;
                  break;
                }
                error = Device_read(&deviceHandle,buffer,bufferBlockCount*deviceInfo.blockSize,NULL);
                if (error != ERROR_NONE)
                {
                  printInfo(2,"FAIL!\n");
                  printError("Cannot read file '%s' (error: %s)\n",
                             String_cString(imageName),
                             Errors_getText(error)
                            );
                  if (jobOptions->stopOnErrorFlag)
                  {
                    failError = error;
                  }
                  break;
                }

                /* compare */
                diffIndex = compare(archiveBuffer,buffer,bufferBlockCount*deviceInfo.blockSize);
                equalFlag = (diffIndex >= bufferBlockCount*deviceInfo.blockSize);
                if (!equalFlag)
                {
                  printInfo(2,"FAIL!\n");
                  printError("'%s' differ at offset %llu\n",
                             String_cString(imageName),
                             blockOffset*(uint64)deviceInfo.blockSize+block*(uint64)deviceInfo.blockSize+(uint64)diffIndex
                            );
                  if (jobOptions->stopOnErrorFlag)
                  {
                    failError = ERROR_FILES_DIFFER;
                  }
                  break;
                }

                block += (uint64)bufferBlockCount;
              }
              Device_close(&deviceHandle);
              if (failError != ERROR_NONE)
              {
                Archive_closeEntry(&archiveFileInfo);
                String_delete(imageName);
                continue;
              }

#if 0
              /* get local file info */
              /* check file time, permissions, file owner/group */
#endif /* 0 */
              printInfo(2,"ok\n");

              /* add fragment to file fragment list */
              FragmentList_addEntry(fragmentNode,blockOffset*(uint64)deviceInfo.blockSize,blockCount*(uint64)deviceInfo.blockSize);

              /* discard fragment list if file is complete */
              if (FragmentList_checkEntryComplete(fragmentNode))
              {
                FragmentList_remove(&fragmentList,fragmentNode);
              }

              /* free resources */
            }
            else
            {
              /* skip */
              printInfo(3,"  Compare '%s'...skipped\n",String_cString(imageName));
            }

            /* close archive file, free resources */
            Archive_closeEntry(&archiveFileInfo);
            String_delete(imageName);
          }
          break;
        case ARCHIVE_ENTRY_TYPE_DIRECTORY:
          {
            String   directoryName;
            FileInfo fileInfo;
//            String   localFileName;
//            FileInfo localFileInfo;

            /* read directory */
            directoryName = String_new();
            error = Archive_readDirectoryEntry(&archiveInfo,
                                               &archiveFileInfo,
                                               NULL,
                                               NULL,
                                               directoryName,
                                               &fileInfo
                                              );
            if (error != ERROR_NONE)
            {
              printError("Cannot not read 'directory' content of archive '%s' (error: %s)!\n",
                         String_cString(archiveFileName),
                         Errors_getText(error)
                        );
              String_delete(directoryName);
              if (failError == ERROR_NONE) failError = error;
              break;
            }

            if (   (List_empty(includeEntryList) || EntryList_match(includeEntryList,directoryName,PATTERN_MATCH_MODE_EXACT))
                && !PatternList_match(excludePatternList,directoryName,PATTERN_MATCH_MODE_EXACT)
               )
            {
              printInfo(2,"  Compare directory '%s'...",String_cString(directoryName));

              /* check directory */
              if (!File_exists(directoryName))
              {
                printInfo(2,"FAIL!\n");
                printError("Directory '%s' does not exists!\n",String_cString(directoryName));
                Archive_closeEntry(&archiveFileInfo);
                String_delete(directoryName);
                if (jobOptions->stopOnErrorFlag)
                {
                  failError = ERROR_FILE_NOT_FOUND;
                }
                break;
              }
              if (File_getType(directoryName) != FILE_TYPE_DIRECTORY)
              {
                printInfo(2,"FAIL!\n");
                printError("'%s' is not a directory!\n",
                           String_cString(directoryName)
                          );
                Archive_closeEntry(&archiveFileInfo);
                String_delete(directoryName);
                if (jobOptions->stopOnErrorFlag)
                {
                  failError = ERROR_WRONG_FILE_TYPE;
                }
                break;
              }

#if 0
              /* get local file info */
              error = File_getFileInfo(directoryName,&localFileInfo);
              if (error != ERROR_NONE)
              {
                printError("Cannot not read local directory '%s' (error: %s)!\n",
                           String_cString(directoryName),
                           Errors_getText(error)
                          );
                Archive_closeEntry(&archiveFileInfo);
                String_delete(directoryName);
                if (failError == ERROR_NONE) failError = error;
                break;
              }

              /* check file time, permissions, file owner/group */
#endif /* 0 */
              printInfo(2,"ok\n");

              /* free resources */
            }
            else
            {
              /* skip */
              printInfo(3,"  Compare '%s'...skipped\n",String_cString(directoryName));
            }

            /* close archive file */
            Archive_closeEntry(&archiveFileInfo);
            String_delete(directoryName);
          }
          break;
        case ARCHIVE_ENTRY_TYPE_LINK:
          {
            String   linkName;
            String   fileName;
            FileInfo fileInfo;
            String   localFileName;
//            FileInfo localFileInfo;

            /* read link */
            linkName = String_new();
            fileName = String_new();
            error = Archive_readLinkEntry(&archiveInfo,
                                          &archiveFileInfo,
                                          NULL,
                                          NULL,
                                          linkName,
                                          fileName,
                                          &fileInfo
                                         );
            if (error != ERROR_NONE)
            {
              printError("Cannot not read 'link' content of archive '%s' (error: %s)!\n",
                         String_cString(archiveFileName),
                         Errors_getText(error)
                        );
              String_delete(fileName);
              String_delete(linkName);
              if (failError == ERROR_NONE) failError = error;
              break;
            }

            if (   (List_empty(includeEntryList) || EntryList_match(includeEntryList,linkName,PATTERN_MATCH_MODE_EXACT))
                && !PatternList_match(excludePatternList,linkName,PATTERN_MATCH_MODE_EXACT)
               )
            {
              printInfo(2,"  Compare link '%s'...",String_cString(linkName));

              /* check link */
              if (!File_exists(linkName))
              {
                printInfo(2,"FAIL!\n");
                printError("Link '%s' -> '%s' does not exists!\n",
                           String_cString(linkName),
                           String_cString(fileName)
                          );
                Archive_closeEntry(&archiveFileInfo);
                String_delete(fileName);
                String_delete(linkName);
                if (jobOptions->stopOnErrorFlag)
                {
                  failError = ERROR_FILE_NOT_FOUND;
                }
                break;
              }
              if (File_getType(linkName) != FILE_TYPE_LINK)
              {
                printInfo(2,"FAIL!\n");
                printError("'%s' is not a link!\n",
                           String_cString(linkName)
                          );
                Archive_closeEntry(&archiveFileInfo);
                String_delete(fileName);
                String_delete(linkName);
                if (jobOptions->stopOnErrorFlag)
                {
                  failError = ERROR_WRONG_FILE_TYPE;
                }
                break;
              }

              /* check link content */
              localFileName = String_new();
              error = File_readLink(linkName,localFileName);
              if (error != ERROR_NONE)
              {
                printError("Cannot not read local file '%s' (error: %s)!\n",
                           String_cString(linkName),
                           Errors_getText(error)
                          );
                String_delete(localFileName);
                Archive_closeEntry(&archiveFileInfo);
                String_delete(fileName);
                String_delete(linkName);
                if (jobOptions->stopOnErrorFlag)
                {
                  failError = error;
                }
                break;
              }
              if (!String_equals(fileName,localFileName))
              {
                printInfo(2,"FAIL!\n");
                printError("Link '%s' does not contain file '%s'!\n",
                           String_cString(linkName),
                           String_cString(fileName)
                          );
                String_delete(localFileName);
                Archive_closeEntry(&archiveFileInfo);
                String_delete(fileName);
                String_delete(linkName);
                if (jobOptions->stopOnErrorFlag)
                {
                  failError = ERROR_FILES_DIFFER;
                }
                break;
              }
              String_delete(localFileName);

#if 0
              /* get local file info */
              error = File_getFileInfo(linkName,&localFileInfo);
              if (error != ERROR_NONE)
              {
                printError("Cannot not read local file '%s' (error: %s)!\n",
                           String_cString(linkName),
                           Errors_getText(error)
                          );
                Archive_closeEntry(&archiveFileInfo);
                String_delete(fileName);
                String_delete(linkName);
                if (failError == ERROR_NONE) failError = error;
                break;
              }

              /* check file time, permissions, file owner/group */
#endif /* 0 */
              printInfo(2,"ok\n");

              /* free resources */
            }
            else
            {
              /* skip */
              printInfo(3,"  Compare '%s'...skipped\n",String_cString(linkName));
            }

            /* close archive file */
            Archive_closeEntry(&archiveFileInfo);
            String_delete(fileName);
            String_delete(linkName);
          }
          break;
        case ARCHIVE_ENTRY_TYPE_SPECIAL:
          {
            String   fileName;
            FileInfo fileInfo;
            FileInfo localFileInfo;

            /* read special */
            fileName = String_new();
            error = Archive_readSpecialEntry(&archiveInfo,
                                             &archiveFileInfo,
                                             NULL,
                                             NULL,
                                             fileName,
                                             &fileInfo
                                            );
            if (error != ERROR_NONE)
            {
              printError("Cannot not read 'special' content of archive '%s' (error: %s)!\n",
                         String_cString(archiveFileName),
                         Errors_getText(error)
                        );
              String_delete(fileName);
              if (failError == ERROR_NONE) failError = error;
              break;
            }

            if (   (List_empty(includeEntryList) || EntryList_match(includeEntryList,fileName,PATTERN_MATCH_MODE_EXACT))
                && !PatternList_match(excludePatternList,fileName,PATTERN_MATCH_MODE_EXACT)
               )
            {
              printInfo(2,"  Compare special device '%s'...",String_cString(fileName));

              /* check special device */
              if (!File_exists(fileName))
              {
                printInfo(2,"FAIL!\n");
                printError("Special device '%s' does not exists!\n",
                           String_cString(fileName)
                          );
                Archive_closeEntry(&archiveFileInfo);
                String_delete(fileName);
                if (jobOptions->stopOnErrorFlag)
                {
                  failError = ERROR_FILE_NOT_FOUND;
                }
                break;
              }
              if (File_getType(fileName) != FILE_TYPE_SPECIAL)
              {
                printInfo(2,"FAIL!\n");
                printError("'%s' is not a special device!\n",
                           String_cString(fileName)
                          );
                Archive_closeEntry(&archiveFileInfo);
                String_delete(fileName);
                if (jobOptions->stopOnErrorFlag)
                {
                  failError = ERROR_WRONG_FILE_TYPE;
                }
                break;
              }

              /* check special settings */
              error = File_getFileInfo(fileName,&localFileInfo);
              if (error != ERROR_NONE)
              {
                printError("Cannot not read local file '%s' (error: %s)!\n",
                           String_cString(fileName),
                           Errors_getText(error)
                          );
                Archive_closeEntry(&archiveFileInfo);
                String_delete(fileName);
                if (jobOptions->stopOnErrorFlag)
                {
                  failError = error;
                }
                break;
              }
              if (fileInfo.specialType != localFileInfo.specialType)
              {
                printError("Different types of special device '%s'!\n",
                           String_cString(fileName)
                          );
                Archive_closeEntry(&archiveFileInfo);
                String_delete(fileName);
                if (jobOptions->stopOnErrorFlag)
                {
                  failError = error;
                }
                break;
              }
              if (   (fileInfo.specialType == FILE_SPECIAL_TYPE_CHARACTER_DEVICE)
                  || (fileInfo.specialType == FILE_SPECIAL_TYPE_BLOCK_DEVICE)
                 )
              {
                if (fileInfo.major != localFileInfo.major)
                {
                  printError("Different major numbers of special device '%s'!\n",
                             String_cString(fileName)
                            );
                  Archive_closeEntry(&archiveFileInfo);
                  String_delete(fileName);
                  if (jobOptions->stopOnErrorFlag)
                  {
                    failError = error;
                  }
                  break;
                }
                if (fileInfo.minor != localFileInfo.minor)
                {
                  printError("Different minor numbers of special device '%s'!\n",
                             String_cString(fileName)
                            );
                  Archive_closeEntry(&archiveFileInfo);
                  String_delete(fileName);
                  if (jobOptions->stopOnErrorFlag)
                  {
                    failError = error;
                  }
                  break;
                }
              }

#if 0

              /* check file time, permissions, file owner/group */
#endif /* 0 */

              printInfo(2,"ok\n");

              /* free resources */
            }
            else
            {
              /* skip */
              printInfo(3,"  Compare '%s'...skipped\n",String_cString(fileName));
            }

            /* close archive file */
            Archive_closeEntry(&archiveFileInfo);
            String_delete(fileName);
          }
          break;
        default:
          #ifndef NDEBUG
            HALT_INTERNAL_ERROR_UNHANDLED_SWITCH_CASE();
          #endif /* NDEBUG */
          break; /* not reached */
      }
    }

    /* close archive */
    Archive_close(&archiveInfo);
  }

  /* check fragment lists */
  for (fragmentNode = fragmentList.head; fragmentNode != NULL; fragmentNode = fragmentNode->next)
  {
    if (!FragmentList_checkEntryComplete(fragmentNode))
    {
      printInfo(0,"Warning: incomplete entry '%s'\n",String_cString(fragmentNode->name));
      if (failError == ERROR_NONE) failError = ERROR_FILE_INCOMPLETE;
    }
  }

  /* free resources */
  String_delete(archiveFileName);
  FragmentList_done(&fragmentList);
  free(buffer);
  free(archiveBuffer);

  return failError;
}
Beispiel #5
0
Errors File_open(FileHandle    *fileHandle,
                 const String  fileName,
                 FileOpenModes fileOpenMode
                )
{
  off_t  n;
  Errors error;
  String pathName;

  assert(fileHandle != NULL);
  assert(fileName != NULL);

  switch (fileOpenMode)
  {
    case FILE_OPENMODE_CREATE:
      /* create file */
      fileHandle->file = fopen(String_cString(fileName),"wb");
      if (fileHandle->file == NULL)
      {
        return ERRORX(CREATE_FILE,errno,String_cString(fileName));
      }

      fileHandle->name  = String_duplicate(fileName);;
      fileHandle->index = 0LL;
      fileHandle->size  = 0LL;
      break;
    case FILE_OPENMODE_READ:
      /* open file for reading */
      fileHandle->file = fopen(String_cString(fileName),"rb");
      if (fileHandle->file == NULL)
      {
        return ERRORX(OPEN_FILE,errno,String_cString(fileName));
      }

      /* get file size */
      if (fseeko(fileHandle->file,(off_t)0,SEEK_END) == -1)
      {
        error = ERRORX(IO_ERROR,errno,String_cString(fileName));
        fclose(fileHandle->file);
        return error;
      }
      n = ftello(fileHandle->file);
      if (n == (off_t)-1)
      {
        error = ERRORX(IO_ERROR,errno,String_cString(fileName));
        fclose(fileHandle->file);
        return error;
      }
      if (fseeko(fileHandle->file,(off_t)0,SEEK_SET) == -1)
      {
        error = ERRORX(IO_ERROR,errno,String_cString(fileName));
        fclose(fileHandle->file);
        return error;
      }

      fileHandle->name  = String_duplicate(fileName);;
      fileHandle->index = 0LL;
      fileHandle->size  = (uint64)n;
      break;
    case FILE_OPENMODE_WRITE:
      /* create directory if needed */
      pathName = File_getFilePathName(File_newFileName(),fileName);
      if (!File_exists(pathName))
      {
        error = File_makeDirectory(pathName,
                                   FILE_DEFAULT_USER_ID,
                                   FILE_DEFAULT_GROUP_ID,
                                   FILE_DEFAULT_PERMISSION
                                  );
        if (error != ERROR_NONE)
        {
          return error;
        }
      }
      File_deleteFileName(pathName);

      /* open existing file for writing */
      fileHandle->file = fopen(String_cString(fileName),"r+b");
      if (fileHandle->file == NULL)
      {
        if (errno == ENOENT)
        {
          fileHandle->file = fopen(String_cString(fileName),"wb");
          if (fileHandle->file == NULL)
          {
            return ERRORX(OPEN_FILE,errno,String_cString(fileName));
          }
        }
        else
        {
          return ERRORX(OPEN_FILE,errno,String_cString(fileName));
        }
      }

      fileHandle->name  = String_duplicate(fileName);;
      fileHandle->index = 0LL;
      fileHandle->size  = 0LL;
      break;
    case FILE_OPENMODE_APPEND:
      /* create directory if needed */
      pathName = File_getFilePathName(File_newFileName(),fileName);
      if (!File_exists(pathName))
      {
        error = File_makeDirectory(pathName,
                                   FILE_DEFAULT_USER_ID,
                                   FILE_DEFAULT_GROUP_ID,
                                   FILE_DEFAULT_PERMISSION
                                  );
        if (error != ERROR_NONE)
        {
          return error;
        }
      }
      File_deleteFileName(pathName);

      /* open existing file for writing */
      fileHandle->file = fopen(String_cString(fileName),"ab");
      if (fileHandle->file == NULL)
      {
        return ERRORX(OPEN_FILE,errno,String_cString(fileName));
      }

      /* get file size */
      n = ftello(fileHandle->file);
      if (n == (off_t)-1)
      {
        error = ERRORX(IO_ERROR,errno,String_cString(fileName));
        fclose(fileHandle->file);
        return error;
      }

      fileHandle->name  = String_duplicate(fileName);;
      fileHandle->index = (uint64)n;
      fileHandle->size  = (uint64)n;
      break;
    #ifndef NDEBUG
      default:
        HALT_INTERNAL_ERROR_UNHANDLED_SWITCH_CASE();
        break; /* not reached */
    #endif /* NDEBUG */
  }

  return ERROR_NONE;
}
Beispiel #6
0
Errors File_makeDirectory(const String pathName,
                          uint32       userId,
                          uint32       groupId,
                          uint32       permission
                         )
{
  mode_t          currentCreationMask;
  StringTokenizer pathNameTokenizer;
  String          directoryName;
  uid_t           uid;
  gid_t           gid;
  Errors          error;
  String          name;

  assert(pathName != NULL);

  /* get current umask */
  currentCreationMask = umask(0);
  umask(currentCreationMask);

  /* create directory including parent directories */
  directoryName = File_newFileName();
  File_initSplitFileName(&pathNameTokenizer,pathName);
  if (File_getNextSplitFileName(&pathNameTokenizer,&name))
  {
    if (String_length(name) > 0)
    {
      File_setFileName(directoryName,name);
    }
    else
    {
      File_setFileNameChar(directoryName,FILES_PATHNAME_SEPARATOR_CHAR);
    }
  }
  if (!File_exists(directoryName))
  {
    if (mkdir(String_cString(directoryName),0777 & ~currentCreationMask) != 0)
    {
      error = ERRORX(IO_ERROR,errno,String_cString(directoryName));
      File_doneSplitFileName(&pathNameTokenizer);
      File_deleteFileName(directoryName);
      return error;
    }
    if (   (userId  != FILE_DEFAULT_USER_ID)
        || (groupId != FILE_DEFAULT_GROUP_ID)
       )
    {
      uid = (userId  != FILE_DEFAULT_USER_ID ) ? (uid_t)userId  : -1;
      gid = (groupId != FILE_DEFAULT_GROUP_ID) ? (gid_t)groupId : -1;
      if (chown(String_cString(directoryName),uid,gid) != 0)
      {
        error = ERRORX(IO_ERROR,errno,String_cString(directoryName));
        File_doneSplitFileName(&pathNameTokenizer);
        File_deleteFileName(directoryName);
        return error;
      }
    }
    if (permission != FILE_DEFAULT_PERMISSION)
    {
      if (chmod(String_cString(directoryName),(permission|S_IXUSR|S_IXGRP|S_IXOTH) & ~currentCreationMask) != 0)
      {
        error = ERROR(IO_ERROR,errno);
        File_doneSplitFileName(&pathNameTokenizer);
        File_deleteFileName(directoryName);
        return error;
      }
    }
  }
  while (File_getNextSplitFileName(&pathNameTokenizer,&name))
  {
    if (String_length(name) > 0)
    {     
      File_appendFileName(directoryName,name);

      if (!File_exists(directoryName))
      {
        if (mkdir(String_cString(directoryName),0777 & ~currentCreationMask) != 0)
        {
          error = ERRORX(IO_ERROR,errno,String_cString(directoryName));
          File_doneSplitFileName(&pathNameTokenizer);
          File_deleteFileName(directoryName);
          return error;
        }
        if (   (userId  != FILE_DEFAULT_USER_ID)
            || (groupId != FILE_DEFAULT_GROUP_ID)
           )
        {
          uid = (userId  != FILE_DEFAULT_USER_ID ) ? (uid_t)userId  : -1;
          gid = (groupId != FILE_DEFAULT_GROUP_ID) ? (gid_t)groupId : -1;
          if (chown(String_cString(directoryName),uid,gid) != 0)
          {
            error = ERRORX(IO_ERROR,errno,String_cString(directoryName));
            File_doneSplitFileName(&pathNameTokenizer);
            File_deleteFileName(directoryName);
            return error;
          }
        }
        if (permission != FILE_DEFAULT_PERMISSION)
        {
          if (chmod(String_cString(directoryName),(permission|S_IXUSR|S_IXGRP|S_IXOTH) & ~currentCreationMask) != 0)
          {
            error = ERRORX(IO_ERROR,errno,String_cString(directoryName));
            File_doneSplitFileName(&pathNameTokenizer);
            File_deleteFileName(directoryName);
            return error;
          }
        }
      }
    }
  }
  File_doneSplitFileName(&pathNameTokenizer);
  File_deleteFileName(directoryName);

  return ERROR_NONE;
}
Errors Command_restore(StringList                      *archiveFileNameList,
                       PatternList                     *includePatternList,
                       PatternList                     *excludePatternList,
                       JobOptions                      *jobOptions,
                       ArchiveGetCryptPasswordFunction archiveGetCryptPasswordFunction,
                       void                            *archiveGetCryptPasswordUserData,
                       RestoreStatusInfoFunction       restoreStatusInfoFunction,
                       void                            *restoreStatusInfoUserData,
                       bool                            *pauseFlag,
                       bool                            *requestedAbortFlag
                      )
{
    RestoreInfo       restoreInfo;
    byte              *buffer;
    FileFragmentList  fileFragmentList;
    String            archiveFileName;
    Errors            error;
    ArchiveInfo       archiveInfo;
    ArchiveFileInfo   archiveFileInfo;
    FileTypes         fileType;
    FileFragmentNode  *fileFragmentNode;

    assert(archiveFileNameList != NULL);
    assert(includePatternList != NULL);
    assert(excludePatternList != NULL);
    assert(jobOptions != NULL);

    /* initialize variables */
    restoreInfo.includePatternList           = includePatternList;
    restoreInfo.excludePatternList           = excludePatternList;
    restoreInfo.jobOptions                   = jobOptions;
    restoreInfo.pauseFlag                    = pauseFlag;
    restoreInfo.requestedAbortFlag           = requestedAbortFlag;
    restoreInfo.error                        = ERROR_NONE;
    restoreInfo.statusInfoFunction           = restoreStatusInfoFunction;
    restoreInfo.statusInfoUserData           = restoreStatusInfoUserData;
    restoreInfo.statusInfo.doneFiles         = 0L;
    restoreInfo.statusInfo.doneBytes         = 0LL;
    restoreInfo.statusInfo.skippedFiles      = 0L;
    restoreInfo.statusInfo.skippedBytes      = 0LL;
    restoreInfo.statusInfo.errorFiles        = 0L;
    restoreInfo.statusInfo.errorBytes        = 0LL;
    restoreInfo.statusInfo.fileName          = String_new();
    restoreInfo.statusInfo.fileDoneBytes     = 0LL;
    restoreInfo.statusInfo.fileTotalBytes    = 0LL;
    restoreInfo.statusInfo.storageName       = String_new();
    restoreInfo.statusInfo.storageDoneBytes  = 0LL;
    restoreInfo.statusInfo.storageTotalBytes = 0LL;

    /* allocate resources */
    buffer = malloc(BUFFER_SIZE);
    if (buffer == NULL)
    {
        HALT_INSUFFICIENT_MEMORY();
    }
    FileFragmentList_init(&fileFragmentList);
    archiveFileName = String_new();

    while (   ((restoreInfo.requestedAbortFlag == NULL) || !(*restoreInfo.requestedAbortFlag))
              && !StringList_empty(archiveFileNameList)
              && (restoreInfo.error == ERROR_NONE)
          )
    {
        /* pause */
        while ((restoreInfo.pauseFlag != NULL) && (*restoreInfo.pauseFlag))
        {
            Misc_udelay(500*1000);
        }

        StringList_getFirst(archiveFileNameList,archiveFileName);
        printInfo(0,"Restore archive '%s':\n",String_cString(archiveFileName));

        /* open archive */
        error = Archive_open(&archiveInfo,
                             archiveFileName,
                             jobOptions,
                             archiveGetCryptPasswordFunction,
                             archiveGetCryptPasswordUserData
                            );
        if (error != ERROR_NONE)
        {
            printError("Cannot open archive file '%s' (error: %s)!\n",
                       String_cString(archiveFileName),
                       Errors_getText(error)
                      );
            if (restoreInfo.error == ERROR_NONE) restoreInfo.error = error;
            continue;
        }
        String_set(restoreInfo.statusInfo.storageName,archiveFileName);
        updateStatusInfo(&restoreInfo);

        /* read files */
        while (   ((restoreInfo.requestedAbortFlag == NULL) || !(*restoreInfo.requestedAbortFlag))
                  && !Archive_eof(&archiveInfo)
                  && (restoreInfo.error == ERROR_NONE)
              )
        {
            /* pause */
            while ((restoreInfo.pauseFlag != NULL) && (*restoreInfo.pauseFlag))
            {
                Misc_udelay(500*1000);
            }

            /* get next file type */
            error = Archive_getNextFileType(&archiveInfo,
                                            &archiveFileInfo,
                                            &fileType
                                           );
            if (error != ERROR_NONE)
            {
                printError("Cannot not read next entry in archive '%s' (error: %s)!\n",
                           String_cString(archiveFileName),
                           Errors_getText(error)
                          );
                if (restoreInfo.error == ERROR_NONE) restoreInfo.error = error;
                break;
            }

            switch (fileType)
            {
            case FILE_TYPE_FILE:
            {
                String           fileName;
                FileInfo         fileInfo;
                uint64           fragmentOffset,fragmentSize;
                FileFragmentNode *fileFragmentNode;
                String           destinationFileName;
                String           directoryName;
//            FileInfo         localFileInfo;
                FileHandle       fileHandle;
                uint64           length;
                ulong            n;

                /* read file */
                fileName = String_new();
                error = Archive_readFileEntry(&archiveInfo,
                                              &archiveFileInfo,
                                              NULL,
                                              NULL,
                                              NULL,
                                              fileName,
                                              &fileInfo,
                                              &fragmentOffset,
                                              &fragmentSize
                                             );
                if (error != ERROR_NONE)
                {
                    printError("Cannot not read 'file' content of archive '%s' (error: %s)!\n",
                               String_cString(archiveFileName),
                               Errors_getText(error)
                              );
                    String_delete(fileName);
                    if (restoreInfo.error == ERROR_NONE) restoreInfo.error = error;
                    continue;
                }

                if (   (List_empty(includePatternList) || PatternList_match(includePatternList,fileName,PATTERN_MATCH_MODE_EXACT))
                        && !PatternList_match(excludePatternList,fileName,PATTERN_MATCH_MODE_EXACT)
                   )
                {
                    String_set(restoreInfo.statusInfo.fileName,fileName);
                    restoreInfo.statusInfo.fileDoneBytes = 0LL;
                    restoreInfo.statusInfo.fileTotalBytes = fragmentSize;
                    updateStatusInfo(&restoreInfo);

                    /* get destination filename */
                    destinationFileName = getDestinationFileName(String_new(),
                                          fileName,
                                          jobOptions->directory,
                                          jobOptions->directoryStripCount
                                                                );


                    /* check if file fragment exists */
                    fileFragmentNode = FileFragmentList_findFile(&fileFragmentList,fileName);
                    if (fileFragmentNode != NULL)
                    {
                        if (!jobOptions->overwriteFilesFlag && FileFragmentList_checkExists(fileFragmentNode,fragmentOffset,fragmentSize))
                        {
                            printInfo(1,"  Restore file '%s'...skipped (file part %ll..%ll exists)\n",
                                      String_cString(destinationFileName),
                                      fragmentOffset,
                                      (fragmentSize > 0)?fragmentOffset+fragmentSize-1:fragmentOffset
                                     );
                            String_delete(destinationFileName);
                            Archive_closeEntry(&archiveFileInfo);
                            String_delete(fileName);
                            continue;
                        }
                    }
                    else
                    {
                        if (!jobOptions->overwriteFilesFlag && File_exists(destinationFileName))
                        {
                            printInfo(1,"  Restore file '%s'...skipped (file exists)\n",String_cString(destinationFileName));
                            String_delete(destinationFileName);
                            Archive_closeEntry(&archiveFileInfo);
                            String_delete(fileName);
                            continue;
                        }
                        fileFragmentNode = FileFragmentList_addFile(&fileFragmentList,fileName,fileInfo.size);
                    }

                    printInfo(2,"  Restore file '%s'...",String_cString(destinationFileName));

                    /* create directory if not existing */
                    directoryName = File_getFilePathName(String_new(),destinationFileName);
                    if (!File_exists(directoryName))
                    {
                        /* create directory */
                        error = File_makeDirectory(directoryName,
                                                   FILE_DEFAULT_USER_ID,
                                                   FILE_DEFAULT_GROUP_ID,
                                                   fileInfo.permission
                                                  );
                        if (error != ERROR_NONE)
                        {
                            printInfo(2,"FAIL!\n");
                            printError("Cannot create directory '%s' (error: %s)\n",
                                       String_cString(directoryName),
                                       Errors_getText(error)
                                      );
                            String_delete(directoryName);
                            String_delete(destinationFileName);
                            Archive_closeEntry(&archiveFileInfo);
                            String_delete(fileName);
                            if (restoreInfo.error == ERROR_NONE) restoreInfo.error = error;
                            continue;
                        }

                        /* set owner ship */
                        error = File_setOwner(directoryName,
                                              (jobOptions->owner.userId  != FILE_DEFAULT_USER_ID )?jobOptions->owner.userId:fileInfo.userId,
                                              (jobOptions->owner.groupId != FILE_DEFAULT_GROUP_ID)?jobOptions->owner.groupId:fileInfo.groupId
                                             );
                        if (error != ERROR_NONE)
                        {
                            if (jobOptions->stopOnErrorFlag)
                            {
                                printInfo(2,"FAIL!\n");
                                printError("Cannot set owner ship of directory '%s' (error: %s)\n",
                                           String_cString(directoryName),
                                           Errors_getText(error)
                                          );
                                String_delete(directoryName);
                                String_delete(destinationFileName);
                                Archive_closeEntry(&archiveFileInfo);
                                String_delete(fileName);
                                if (restoreInfo.error == ERROR_NONE) restoreInfo.error = error;
                                continue;
                            }
                            else
                            {
                                printWarning("Cannot set owner ship of directory '%s' (error: %s)\n",
                                             String_cString(directoryName),
                                             Errors_getText(error)
                                            );
                            }
                        }
                    }
                    String_delete(directoryName);

                    /* write file data */
//if (fileFragmentNode == NULL) File_delete(destinationFileName,TRUE);
                    error = File_open(&fileHandle,destinationFileName,FILE_OPENMODE_WRITE);
                    if (error != ERROR_NONE)
                    {
                        printInfo(2,"FAIL!\n");
                        printError("Cannot create/write to file '%s' (error: %s)\n",
                                   String_cString(destinationFileName),
                                   Errors_getText(error)
                                  );
                        String_delete(destinationFileName);
                        Archive_closeEntry(&archiveFileInfo);
                        String_delete(fileName);
                        if (jobOptions->stopOnErrorFlag)
                        {
                            restoreInfo.error = error;
                        }
                        continue;
                    }
                    error = File_seek(&fileHandle,fragmentOffset);
                    if (error != ERROR_NONE)
                    {
                        printInfo(2,"FAIL!\n");
                        printError("Cannot write file '%s' (error: %s)\n",
                                   String_cString(destinationFileName),
                                   Errors_getText(error)
                                  );
                        File_close(&fileHandle);
                        String_delete(destinationFileName);
                        Archive_closeEntry(&archiveFileInfo);
                        String_delete(fileName);
                        if (jobOptions->stopOnErrorFlag)
                        {
                            restoreInfo.error = error;
                        }
                        continue;
                    }

                    length = 0;
                    while (   ((restoreInfo.requestedAbortFlag == NULL) || !(*restoreInfo.requestedAbortFlag))
                              && (length < fragmentSize)
                          )
                    {
                        /* pause */
                        while ((restoreInfo.pauseFlag != NULL) && (*restoreInfo.pauseFlag))
                        {
                            Misc_udelay(500*1000);
                        }

                        n = MIN(fragmentSize-length,BUFFER_SIZE);

                        error = Archive_readFileData(&archiveFileInfo,buffer,n);
                        if (error != ERROR_NONE)
                        {
                            printInfo(2,"FAIL!\n");
                            printError("Cannot not read content of archive '%s' (error: %s)!\n",
                                       String_cString(archiveFileName),
                                       Errors_getText(error)
                                      );
                            if (restoreInfo.error == ERROR_NONE) restoreInfo.error = error;
                            break;
                        }
                        error = File_write(&fileHandle,buffer,n);
                        if (error != ERROR_NONE)
                        {
                            printInfo(2,"FAIL!\n");
                            printError("Cannot write file '%s' (error: %s)\n",
                                       String_cString(destinationFileName),
                                       Errors_getText(error)
                                      );
                            if (jobOptions->stopOnErrorFlag)
                            {
                                restoreInfo.error = error;
                            }
                            break;
                        }
                        restoreInfo.statusInfo.fileDoneBytes += n;
                        updateStatusInfo(&restoreInfo);

                        length += n;
                    }
                    if (File_getSize(&fileHandle) > fileInfo.size)
                    {
                        File_truncate(&fileHandle,fileInfo.size);
                    }
                    File_close(&fileHandle);
                    if ((restoreInfo.requestedAbortFlag != NULL) && (*restoreInfo.requestedAbortFlag))
                    {
                        printInfo(2,"ABORTED\n");
                        String_delete(destinationFileName);
                        Archive_closeEntry(&archiveFileInfo);
                        String_delete(fileName);
                        continue;
                    }
#if 0
                    if (restoreInfo.error != ERROR_NONE)
                    {
                        String_delete(destinationFileName);
                        Archive_closeEntry(&archiveFileInfo);
                        String_delete(fileName);
                        continue;
                    }
#endif /* 0 */

                    /* set file time, file owner/group */
                    if (jobOptions->owner.userId  != FILE_DEFAULT_USER_ID ) fileInfo.userId  = jobOptions->owner.userId;
                    if (jobOptions->owner.groupId != FILE_DEFAULT_GROUP_ID) fileInfo.groupId = jobOptions->owner.groupId;
                    error = File_setFileInfo(destinationFileName,&fileInfo);
                    if (error != ERROR_NONE)
                    {
                        if (jobOptions->stopOnErrorFlag)
                        {
                            printInfo(2,"FAIL!\n");
                            printError("Cannot set file info of '%s' (error: %s)\n",
                                       String_cString(destinationFileName),
                                       Errors_getText(error)
                                      );
                            String_delete(destinationFileName);
                            Archive_closeEntry(&archiveFileInfo);
                            String_delete(fileName);
                            restoreInfo.error = error;
                            continue;
                        }
                        else
                        {
                            printWarning("Cannot set file info of '%s' (error: %s)\n",
                                         String_cString(destinationFileName),
                                         Errors_getText(error)
                                        );
                        }
                    }

                    /* add fragment to file fragment list */
                    FileFragmentList_add(fileFragmentNode,fragmentOffset,fragmentSize);
//FileFragmentList_print(fileFragmentNode,String_cString(fileName));

                    /* discard fragment list if file is complete */
                    if (FileFragmentList_checkComplete(fileFragmentNode))
                    {
                        FileFragmentList_removeFile(&fileFragmentList,fileFragmentNode);
                    }

                    /* free resources */
                    String_delete(destinationFileName);

                    printInfo(2,"ok\n");
                }
                else
                {
                    /* skip */
                    printInfo(3,"  Restore '%s'...skipped\n",String_cString(fileName));
                }

                /* close archive file, free resources */
                Archive_closeEntry(&archiveFileInfo);
                String_delete(fileName);
            }
            break;
            case FILE_TYPE_DIRECTORY:
            {
                String   directoryName;
                FileInfo fileInfo;
                String   destinationFileName;
//            FileInfo localFileInfo;

                /* read directory */
                directoryName = String_new();
                error = Archive_readDirectoryEntry(&archiveInfo,
                                                   &archiveFileInfo,
                                                   NULL,
                                                   NULL,
                                                   directoryName,
                                                   &fileInfo
                                                  );
                if (error != ERROR_NONE)
                {
                    printError("Cannot not read 'directory' content of archive '%s' (error: %s)!\n",
                               String_cString(archiveFileName),
                               Errors_getText(error)
                              );
                    String_delete(directoryName);
                    if (restoreInfo.error == ERROR_NONE) restoreInfo.error = error;
                    break;
                }

                if (   (List_empty(includePatternList) || PatternList_match(includePatternList,directoryName,PATTERN_MATCH_MODE_EXACT))
                        && !PatternList_match(excludePatternList,directoryName,PATTERN_MATCH_MODE_EXACT)
                   )
                {
                    String_set(restoreInfo.statusInfo.fileName,directoryName);
                    restoreInfo.statusInfo.fileDoneBytes = 0LL;
                    restoreInfo.statusInfo.fileTotalBytes = 00L;
                    updateStatusInfo(&restoreInfo);

                    /* get destination filename */
                    destinationFileName = getDestinationFileName(String_new(),
                                          directoryName,
                                          jobOptions->directory,
                                          jobOptions->directoryStripCount
                                                                );


                    /* check if directory already exists */
                    if (!jobOptions->overwriteFilesFlag && File_exists(destinationFileName))
                    {
                        printInfo(1,
                                  "  Restore directory '%s'...skipped (file exists)\n",
                                  String_cString(destinationFileName)
                                 );
                        String_delete(destinationFileName);
                        Archive_closeEntry(&archiveFileInfo);
                        String_delete(directoryName);
                        continue;
                    }

                    printInfo(2,"  Restore directory '%s'...",String_cString(destinationFileName));

                    /* create directory */
                    error = File_makeDirectory(destinationFileName,
                                               FILE_DEFAULT_USER_ID,
                                               FILE_DEFAULT_GROUP_ID,
                                               fileInfo.permission
                                              );
                    if (error != ERROR_NONE)
                    {
                        printInfo(2,"FAIL!\n");
                        printError("Cannot create directory '%s' (error: %s)\n",
                                   String_cString(destinationFileName),
                                   Errors_getText(error)
                                  );
                        String_delete(destinationFileName);
                        Archive_closeEntry(&archiveFileInfo);
                        String_delete(directoryName);
                        if (jobOptions->stopOnErrorFlag)
                        {
                            restoreInfo.error = error;
                        }
                        continue;
                    }

                    /* set file time, file owner/group */
                    if (jobOptions->owner.userId  != FILE_DEFAULT_USER_ID ) fileInfo.userId  = jobOptions->owner.userId;
                    if (jobOptions->owner.groupId != FILE_DEFAULT_GROUP_ID) fileInfo.groupId = jobOptions->owner.groupId;
                    error = File_setFileInfo(destinationFileName,&fileInfo);
                    if (error != ERROR_NONE)
                    {
                        if (jobOptions->stopOnErrorFlag)
                        {
                            printInfo(2,"FAIL!\n");
                            printError("Cannot set directory info of '%s' (error: %s)\n",
                                       String_cString(destinationFileName),
                                       Errors_getText(error)
                                      );
                            String_delete(destinationFileName);
                            Archive_closeEntry(&archiveFileInfo);
                            String_delete(directoryName);
                            if (jobOptions->stopOnErrorFlag)
                            {
                                restoreInfo.error = error;
                            }
                            continue;
                        }
                        else
                        {
                            printWarning("Cannot set directory info of '%s' (error: %s)\n",
                                         String_cString(destinationFileName),
                                         Errors_getText(error)
                                        );
                        }
                    }

                    /* free resources */
                    String_delete(destinationFileName);

                    printInfo(2,"ok\n");
                }
                else
                {
                    /* skip */
                    printInfo(3,"  Restore '%s'...skipped\n",String_cString(directoryName));
                }

                /* close archive file */
                Archive_closeEntry(&archiveFileInfo);
                String_delete(directoryName);
            }
            break;
            case FILE_TYPE_LINK:
            {
                String   linkName;
                String   fileName;
                FileInfo fileInfo;
                String   destinationFileName;
//            FileInfo localFileInfo;

                /* read link */
                linkName = String_new();
                fileName = String_new();
                error = Archive_readLinkEntry(&archiveInfo,
                                              &archiveFileInfo,
                                              NULL,
                                              NULL,
                                              linkName,
                                              fileName,
                                              &fileInfo
                                             );
                if (error != ERROR_NONE)
                {
                    printError("Cannot not read 'link' content of archive '%s' (error: %s)!\n",
                               String_cString(archiveFileName),
                               Errors_getText(error)
                              );
                    String_delete(fileName);
                    String_delete(linkName);
                    if (restoreInfo.error == ERROR_NONE) restoreInfo.error = error;
                    break;
                }

                if (   (List_empty(includePatternList) || PatternList_match(includePatternList,linkName,PATTERN_MATCH_MODE_EXACT))
                        && !PatternList_match(excludePatternList,linkName,PATTERN_MATCH_MODE_EXACT)
                   )
                {
                    String_set(restoreInfo.statusInfo.fileName,linkName);
                    restoreInfo.statusInfo.fileDoneBytes = 0LL;
                    restoreInfo.statusInfo.fileTotalBytes = 00L;
                    updateStatusInfo(&restoreInfo);

                    /* get destination filename */
                    destinationFileName = getDestinationFileName(String_new(),
                                          linkName,
                                          jobOptions->directory,
                                          jobOptions->directoryStripCount
                                                                );


                    /* create link */
                    if (!jobOptions->overwriteFilesFlag && File_exists(destinationFileName))
                    {
                        printInfo(1,
                                  "  Restore link '%s'...skipped (file exists)\n",
                                  String_cString(destinationFileName)
                                 );
                        String_delete(destinationFileName);
                        Archive_closeEntry(&archiveFileInfo);
                        String_delete(fileName);
                        String_delete(linkName);
                        if (jobOptions->stopOnErrorFlag)
                        {
                            restoreInfo.error = ERROR_FILE_EXITS;
                        }
                        continue;
                    }

                    printInfo(2,"  Restore link '%s'...",String_cString(destinationFileName));

                    error = File_makeLink(destinationFileName,fileName);
                    if (error != ERROR_NONE)
                    {
                        printInfo(2,"FAIL!\n");
                        printError("Cannot create link '%s' -> '%s' (error: %s)\n",
                                   String_cString(destinationFileName),
                                   String_cString(fileName),
                                   Errors_getText(error)
                                  );
                        String_delete(destinationFileName);
                        Archive_closeEntry(&archiveFileInfo);
                        String_delete(fileName);
                        String_delete(linkName);
                        if (jobOptions->stopOnErrorFlag)
                        {
                            restoreInfo.error = error;
                        }
                        continue;
                    }

                    /* set file time, file owner/group */
                    if (jobOptions->owner.userId  != FILE_DEFAULT_USER_ID ) fileInfo.userId  = jobOptions->owner.userId;
                    if (jobOptions->owner.groupId != FILE_DEFAULT_GROUP_ID) fileInfo.groupId = jobOptions->owner.groupId;
                    error = File_setFileInfo(destinationFileName,&fileInfo);
                    if (error != ERROR_NONE)
                    {
                        if (jobOptions->stopOnErrorFlag)
                        {
                            printInfo(2,"FAIL!\n");
                            printError("Cannot set file info of '%s' (error: %s)\n",
                                       String_cString(destinationFileName),
                                       Errors_getText(error)
                                      );
                            String_delete(destinationFileName);
                            Archive_closeEntry(&archiveFileInfo);
                            String_delete(fileName);
                            String_delete(linkName);
                            if (jobOptions->stopOnErrorFlag)
                            {
                                restoreInfo.error = error;
                            }
                            continue;
                        }
                        else
                        {
                            printWarning("Cannot set file info of '%s' (error: %s)\n",
                                         String_cString(destinationFileName),
                                         Errors_getText(error)
                                        );
                        }
                    }

                    /* free resources */
                    String_delete(destinationFileName);

                    printInfo(2,"ok\n");
                }
                else
                {
                    /* skip */
                    printInfo(3,"  Restore '%s'...skipped\n",String_cString(linkName));
                }

                /* close archive file */
                Archive_closeEntry(&archiveFileInfo);
                String_delete(fileName);
                String_delete(linkName);
            }
            break;
            case FILE_TYPE_SPECIAL:
            {
                String   fileName;
                FileInfo fileInfo;
                String   destinationFileName;
//            FileInfo localFileInfo;

                /* read special device */
                fileName = String_new();
                error = Archive_readSpecialEntry(&archiveInfo,
                                                 &archiveFileInfo,
                                                 NULL,
                                                 NULL,
                                                 fileName,
                                                 &fileInfo
                                                );
                if (error != ERROR_NONE)
                {
                    printError("Cannot not read 'special' content of archive '%s' (error: %s)!\n",
                               String_cString(archiveFileName),
                               Errors_getText(error)
                              );
                    String_delete(fileName);
                    if (restoreInfo.error == ERROR_NONE) restoreInfo.error = error;
                    break;
                }

                if (   (List_empty(includePatternList) || PatternList_match(includePatternList,fileName,PATTERN_MATCH_MODE_EXACT))
                        && !PatternList_match(excludePatternList,fileName,PATTERN_MATCH_MODE_EXACT)
                   )
                {
                    String_set(restoreInfo.statusInfo.fileName,fileName);
                    restoreInfo.statusInfo.fileDoneBytes = 0LL;
                    restoreInfo.statusInfo.fileTotalBytes = 00L;
                    updateStatusInfo(&restoreInfo);

                    /* get destination filename */
                    destinationFileName = getDestinationFileName(String_new(),
                                          fileName,
                                          jobOptions->directory,
                                          jobOptions->directoryStripCount
                                                                );


                    /* create special device */
                    if (!jobOptions->overwriteFilesFlag && File_exists(destinationFileName))
                    {
                        printInfo(1,
                                  "  Restore special device '%s'...skipped (file exists)\n",
                                  String_cString(destinationFileName)
                                 );
                        String_delete(destinationFileName);
                        Archive_closeEntry(&archiveFileInfo);
                        String_delete(fileName);
                        if (jobOptions->stopOnErrorFlag)
                        {
                            restoreInfo.error = ERROR_FILE_EXITS;
                        }
                        continue;
                    }

                    printInfo(2,"  Restore special device '%s'...",String_cString(destinationFileName));

                    error = File_makeSpecial(destinationFileName,
                                             fileInfo.specialType,
                                             fileInfo.major,
                                             fileInfo.minor
                                            );
                    if (error != ERROR_NONE)
                    {
                        printInfo(2,"FAIL!\n");
                        printError("Cannot create special device '%s' (error: %s)\n",
                                   String_cString(fileName),
                                   Errors_getText(error)
                                  );
                        String_delete(destinationFileName);
                        Archive_closeEntry(&archiveFileInfo);
                        String_delete(fileName);
                        if (jobOptions->stopOnErrorFlag)
                        {
                            restoreInfo.error = error;
                        }
                        continue;
                    }

                    /* set file time, file owner/group */
                    if (jobOptions->owner.userId  != FILE_DEFAULT_USER_ID ) fileInfo.userId  = jobOptions->owner.userId;
                    if (jobOptions->owner.groupId != FILE_DEFAULT_GROUP_ID) fileInfo.groupId = jobOptions->owner.groupId;
                    error = File_setFileInfo(destinationFileName,&fileInfo);
                    if (error != ERROR_NONE)
                    {
                        if (jobOptions->stopOnErrorFlag)
                        {
                            printInfo(2,"FAIL!\n");
                            printError("Cannot set file info of '%s' (error: %s)\n",
                                       String_cString(destinationFileName),
                                       Errors_getText(error)
                                      );
                            String_delete(destinationFileName);
                            Archive_closeEntry(&archiveFileInfo);
                            String_delete(fileName);
                            if (jobOptions->stopOnErrorFlag)
                            {
                                restoreInfo.error = error;
                            }
                            continue;
                        }
                        else
                        {
                            printWarning("Cannot set file info of '%s' (error: %s)\n",
                                         String_cString(destinationFileName),
                                         Errors_getText(error)
                                        );
                        }
                    }

                    /* free resources */
                    String_delete(destinationFileName);

                    printInfo(2,"ok\n");
                }
                else
                {
                    /* skip */
                    printInfo(3,"  Restore '%s'...skipped\n",String_cString(fileName));
                }

                /* close archive file */
                Archive_closeEntry(&archiveFileInfo);
                String_delete(fileName);
            }
            break;
            default:
#ifndef NDEBUG
                HALT_INTERNAL_ERROR_UNHANDLED_SWITCH_CASE();
#endif /* NDEBUG */
                break; /* not reached */
            }
        }

        /* close archive */
        Archive_close(&archiveInfo);
    }

    /* check fragment lists */
    if ((restoreInfo.requestedAbortFlag == NULL) || !(*restoreInfo.requestedAbortFlag))
    {
        for (fileFragmentNode = fileFragmentList.head; fileFragmentNode != NULL; fileFragmentNode = fileFragmentNode->next)
        {
            if (!FileFragmentList_checkComplete(fileFragmentNode))
            {
                printInfo(0,"Warning: incomplete file '%s'\n",String_cString(fileFragmentNode->fileName));
                if (restoreInfo.error == ERROR_NONE) restoreInfo.error = ERROR_FILE_INCOMPLETE;
            }
        }
    }

    /* free resources */
    String_delete(archiveFileName);
    FileFragmentList_done(&fileFragmentList);
    free(buffer);
    String_delete(restoreInfo.statusInfo.fileName);
    String_delete(restoreInfo.statusInfo.storageName);

    if ((restoreInfo.requestedAbortFlag == NULL) || !(*restoreInfo.requestedAbortFlag))
    {
        return restoreInfo.error;
    }
    else
    {
        return ERROR_ABORTED;
    }
}