/[osn-commons]/trunk/uar/main.c
ViewVC logotype

Diff of /trunk/uar/main.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 33 by rakinar2, Thu Aug 8 16:57:39 2024 UTC revision 57 by rakinar2, Sat Sep 7 15:02:56 2024 UTC
# Line 24  Line 24 
24  #include <assert.h>  #include <assert.h>
25  #include <errno.h>  #include <errno.h>
26  #include <getopt.h>  #include <getopt.h>
27    #include <grp.h>
28  #include <libgen.h>  #include <libgen.h>
29  #include <limits.h>  #include <limits.h>
30    #include <linux/limits.h>
31  #include <math.h>  #include <math.h>
32    #include <pwd.h>
33  #include <stdarg.h>  #include <stdarg.h>
34  #include <stdbool.h>  #include <stdbool.h>
35  #include <stdio.h>  #include <stdio.h>
# Line 233  create_archive (void) Line 236  create_archive (void)
236      if (params.verbose)      if (params.verbose)
237          pinfo ("creating archive: %s\n", params.file);          pinfo ("creating archive: %s\n", params.file);
238    
239      struct uar_archive *uar = uar_create_stream ();      struct uar_archive *uar = uar_stream_create ();
240    
241      if (uar == NULL)      if (uar == NULL)
242          {          {
# Line 255  create_archive (void) Line 258  create_archive (void)
258                      return;                      return;
259                  }                  }
260    
261                const char *base = basename (params.rtargets[i]);
262    
263                if (strcmp (base, ".") == 0 || strcmp (base, "..") == 0)
264                    base = basename (params.targets[i]);
265    
266              struct uar_file *file              struct uar_file *file
267                  = uar_stream_add_entry (uar, basename (params.rtargets[i]),                  = uar_stream_add_entry (uar, base, params.rtargets[i], &stinfo);
                                         params.rtargets[i], &stinfo);  
268    
269              if (file == NULL || uar_has_error (uar))              if (file == NULL || uar_has_error (uar))
270                  {                  {
# Line 286  create_archive (void) Line 293  create_archive (void)
293    
294  /* Archive extraction callback. */  /* Archive extraction callback. */
295  static bool  static bool
296  extract_archive_callback (struct uar_file *file)  extract_archive_callback (struct uar_archive *uar,
297                              struct uar_file *file __attribute__ ((unused)),
298                              const char *uar_name __attribute__ ((unused)),
299                              const char *fs_name, enum uar_error_level level,
300                              const char *message)
301  {  {
302      pinfo ("extracting: %s\n", uar_file_get_name (file));      if (level == UAR_ELEVEL_NONE)
303            {
304                if (params.verbose)
305                    fprintf (stdout, "%s\n", fs_name);
306            }
307        else if (level == UAR_ELEVEL_WARNING)
308            perr ("warning: %s: %s\n", fs_name,
309                  message != NULL ? message : uar_strerror (uar));
310        else if (level == UAR_ELEVEL_ERROR)
311            perr ("error: %s: %s\n", fs_name,
312                  message != NULL ? message : uar_strerror (uar));
313    
314      return true;      return true;
315  }  }
316    
# Line 300  extract_archive (void) Line 322  extract_archive (void)
322    
323      pinfo ("extracting archive: %s\n", params.file);      pinfo ("extracting archive: %s\n", params.file);
324    
325      struct uar_archive *uar = uar_open (params.file);      struct uar_archive *uar = uar_stream_open (params.file);
326    
327      if (uar == NULL || uar_has_error (uar))      if (uar == NULL || uar_has_error (uar))
328          {          {
# Line 308  extract_archive (void) Line 330  extract_archive (void)
330              return;              return;
331          }          }
332    
333  #ifdef UAR_PRINT_VERBOSE_IMPL_INFO      uar_set_extract_callback (uar, &extract_archive_callback);
     uar_debug_print (uar, false);  
 #endif  
334    
335      if (!uar_extract (uar, params.cwd, &extract_archive_callback))      if (params.cwd != NULL)
336            {
337                if (chdir (params.cwd) != 0)
338                    {
339                        pinfo ("failed to change working directory: %s\n",
340                               strerror (errno));
341                        return;
342                    }
343            }
344    
345        char *cwd = getcwd (NULL, 0);
346    
347        if (!uar_stream_extract (uar, cwd))
348          {          {
349              pinfo ("failed to extract archive: %s\n", strerror (errno));              pinfo ("failed to extract archive: %s\n", strerror (errno));
350                free (cwd);
351              return;              return;
352          }          }
353    
354        free (cwd);
355      uar_close (uar);      uar_close (uar);
356  }  }
357    
# Line 353  static char * Line 387  static char *
387  format_iec_size (uint64_t size)  format_iec_size (uint64_t size)
388  {  {
389      static char buf[32] = { 0 };      static char buf[32] = { 0 };
390      const char suffix[] = { ' ', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y' };      const char suffix[] = { 0, 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y' };
391      size_t i = 0;      size_t i = 0;
392      long double computed = size;      long double computed = size;
393    
# Line 363  format_iec_size (uint64_t size) Line 397  format_iec_size (uint64_t size)
397              i++;              i++;
398          }          }
399    
400      snprintf (buf, sizeof (buf), "%.02Lf%c", computed, suffix[i]);      if (computed == 0.00)
401            {
402                snprintf (buf, sizeof (buf), "0%c", suffix[i]);
403                return buf;
404            }
405    
406        snprintf (buf, sizeof (buf), "%.2Lf%c", computed, suffix[i]);
407      return buf;      return buf;
408  }  }
409    
410  struct archive_file_info  struct archive_file_info
411  {  {
     mode_t mode;  
412      const char *name;      const char *name;
413        char owner[128];
414        char group[128];
415        mode_t mode;
416      time_t mtime;      time_t mtime;
417      union      union
418      {      {
# Line 384  struct archive_file_table Line 426  struct archive_file_table
426  {  {
427      struct archive_file_info *files;      struct archive_file_info *files;
428      size_t nfiles;      size_t nfiles;
429      int widths[1];      int widths[3];
430  };  };
431    
432  #define TABLE_WIDTH_SIZE 1  #define TABLE_WIDTH_SIZE 0
433    #define TABLE_WIDTH_OWNER 1
434    #define TABLE_WIDTH_GROUP 2
435    
436  static bool  static bool
437  list_archive_callback_analyze (struct uar_file *file, void *data)  list_archive_callback_analyze (struct uar_file *file, void *data)
# Line 404  list_archive_callback_analyze (struct ua Line 448  list_archive_callback_analyze (struct ua
448      info.name = name;      info.name = name;
449      info.mtime = uar_file_get_mtime (file);      info.mtime = uar_file_get_mtime (file);
450    
451        uid_t uid = uar_file_get_uid (file);
452        gid_t gid = uar_file_get_gid (file);
453    
454        struct passwd *pw = getpwuid (uid);
455        struct group *gr = getgrgid (gid);
456    
457        if (pw == NULL)
458            {
459                if (params.verbose)
460                    perr ("warning: failed to get user info (%i): %s\n", uid,
461                          strerror (errno));
462    
463                strncpy (info.owner, "unknown", sizeof (info.owner) - 1);
464            }
465        else
466            strncpy (info.owner, pw->pw_name, sizeof (info.owner) - 1);
467    
468        if (gr == NULL)
469            {
470                if (params.verbose)
471                    perr ("warning: failed to get group info (%i): %s\n", gid,
472                          strerror (errno));
473    
474                strncpy (info.group, "unknown", sizeof (info.group) - 1);
475            }
476        else
477            strncpy (info.group, gr->gr_name, sizeof (info.group) - 1);
478    
479      if (params.hr_sizes)      if (params.hr_sizes)
480          {          {
481              char *str = format_iec_size (size);              char *str = format_iec_size (size);
# Line 419  list_archive_callback_analyze (struct ua Line 491  list_archive_callback_analyze (struct ua
491      if (size_len > table->widths[TABLE_WIDTH_SIZE])      if (size_len > table->widths[TABLE_WIDTH_SIZE])
492          table->widths[TABLE_WIDTH_SIZE] = size_len;          table->widths[TABLE_WIDTH_SIZE] = size_len;
493    
494        int owner_len = strlen (info.owner);
495        int group_len = strlen (info.group);
496    
497        if (owner_len > table->widths[TABLE_WIDTH_OWNER])
498            table->widths[TABLE_WIDTH_OWNER] = owner_len;
499    
500        if (group_len > table->widths[TABLE_WIDTH_GROUP])
501            table->widths[TABLE_WIDTH_GROUP] = group_len;
502    
503      table->files[table->nfiles++] = info;      table->files[table->nfiles++] = info;
504      return true;      return true;
505  }  }
# Line 428  list_archive (void) Line 509  list_archive (void)
509  {  {
510      assert (params.mode == MODE_LIST);      assert (params.mode == MODE_LIST);
511      struct archive_file_table *table = NULL;      struct archive_file_table *table = NULL;
512      struct uar_archive *uar = uar_open (params.file);      struct uar_archive *uar = uar_stream_open (params.file);
513    
514      if (uar == NULL || uar_has_error (uar))      if (uar == NULL)
515          {          {
516              pinfo ("failed to open archive: %s\n", strerror (errno));              pinfo ("failed to open archive file: %s\n", strerror (errno));
517                goto list_archive_end;
518            }
519    
520        if (uar_has_error (uar))
521            {
522                pinfo ("failed to read archive: %s\n", uar_strerror (uar));
523              goto list_archive_end;              goto list_archive_end;
524          }          }
525    
# Line 442  list_archive (void) Line 529  list_archive (void)
529      table->files = xcalloc (nfiles, sizeof (struct archive_file_info));      table->files = xcalloc (nfiles, sizeof (struct archive_file_info));
530      table->nfiles = 0;      table->nfiles = 0;
531    
532      if (!uar_iterate (uar, &list_archive_callback_analyze, (void *) table))      if (!uar_stream_iterate (uar, &list_archive_callback_analyze,
533                                 (void *) table))
534          {          {
535              pinfo ("failed to read archive: %s\n", strerror (errno));              pinfo ("failed to read archive: %s\n", strerror (errno));
536              goto list_archive_end;              goto list_archive_end;
# Line 452  list_archive (void) Line 540  list_archive (void)
540          {          {
541              struct archive_file_info info = table->files[i];              struct archive_file_info info = table->files[i];
542              struct tm *tm = localtime (&info.mtime);              struct tm *tm = localtime (&info.mtime);
543              char mtime_str[10] = "none";              char mtime_str[10] = "never";
544              const char *mode_str = stringify_mode (info.mode);              const char *mode_str = stringify_mode (info.mode);
545    
546              if (tm == NULL)              if (tm == NULL)
547                  {                  {
548                      fprintf (stderr,                      if (params.verbose)
549                               "%s: warning: failed to convert time: %s\n",                          perr ("warning: failed to convert time: %s\n",
550                               progname, strerror (errno));                                strerror (errno));
551                  }                  }
552              else              else
553                  {                  strftime (mtime_str, sizeof (mtime_str), "%b %d", tm);
                     strftime (mtime_str, sizeof (mtime_str), "%b %d", tm);  
                 }  
554    
555              if (params.hr_sizes)              if (params.hr_sizes)
556                  {                  fprintf (stdout, "%s %-*s %-*s %*s %s %s\n", mode_str,
557                             table->widths[TABLE_WIDTH_OWNER], info.owner,
558                             table->widths[TABLE_WIDTH_GROUP], info.group,
559                             table->widths[TABLE_WIDTH_SIZE], info.size.str,
560                             mtime_str, info.name);
561    
                     fprintf (stdout, "%s %*s %s %s\n", mode_str,  
                              table->widths[TABLE_WIDTH_SIZE], info.size.str,  
                              mtime_str, info.name);  
                 }  
562              else              else
563                  {                  fprintf (stdout, "%s %-*s %-*s %*lu %s %s\n", mode_str,
564                             table->widths[TABLE_WIDTH_OWNER], info.owner,
565                      fprintf (stdout, "%s %*lu %s %s\n", mode_str,                           table->widths[TABLE_WIDTH_GROUP], info.group,
566                               table->widths[TABLE_WIDTH_SIZE], info.size.bytes,                           table->widths[TABLE_WIDTH_SIZE], info.size.bytes,
567                               mtime_str, info.name);                           mtime_str, info.name);
                 }  
568          }          }
569    
570  list_archive_end:  list_archive_end:
# Line 673  main (int argc, char **argv) Line 758  main (int argc, char **argv)
758          }          }
759    
760      return 0;      return 0;
 }  
761    }
Legend:
Removed from v.33  
changed lines
  Added in v.57
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26