/[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 32 by rakinar2, Wed Aug 7 18:57:45 2024 UTC revision 40 by rakinar2, Sat Aug 10 14:44:20 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 196  static void Line 199  static void
199  initialize (char *argv0)  initialize (char *argv0)
200  {  {
201      atexit (&cleanup);      atexit (&cleanup);
202        progname = argv0;
     progname = strrchr (argv0, '/');  
   
     if (progname != NULL)  
         progname++;  
     else  
         progname = argv0;  
203  }  }
204    
205  static bool __attribute__ ((unused))  /* Create archive callback. */
206  create_archive_callback (struct uar_archive *uar __attribute__ ((unused)),  static bool
207    create_archive_callback (struct uar_archive *uar,
208                           struct uar_file *file __attribute__ ((unused)),                           struct uar_file *file __attribute__ ((unused)),
209                           const char *fullname __attribute__ ((unused)),                           const char *uar_name __attribute__ ((unused)),
210                           const char *fullpath)                           const char *fs_name, enum uar_error_level level,
211  {                           const char *message)
212      if (!params.verbose)  {
213          return true;      if (level == UAR_ELEVEL_NONE)
214            {
215                if (params.verbose)
216                    fprintf (stdout, "%s\n", fs_name);
217            }
218        else if (level == UAR_ELEVEL_WARNING)
219            perr ("warning: %s: %s\n", fs_name,
220                  message != NULL ? message : uar_strerror (uar));
221        else if (level == UAR_ELEVEL_ERROR)
222            perr ("error: %s: %s\n", fs_name,
223                  message != NULL ? message : uar_strerror (uar));
224    
     fprintf (stdout, "%s\n", fullpath);  
225      return true;      return true;
226  }  }
227    
# Line 229  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 237  create_archive (void) Line 244  create_archive (void)
244              return;              return;
245          }          }
246    
247        uar_set_create_callback (uar, &create_archive_callback);
248    
249      for (size_t i = 0; i < params.ntargets; i++)      for (size_t i = 0; i < params.ntargets; i++)
250          {          {
251              struct stat stinfo = { 0 };              struct stat stinfo = { 0 };
# Line 249  create_archive (void) Line 258  create_archive (void)
258                      return;                      return;
259                  }                  }
260    
261              struct uar_file *file = uar_stream_add_entry (              const char *base = basename (params.rtargets[i]);
262                  uar, basename (params.rtargets[i]), params.rtargets[i], &stinfo,  
263                  &create_archive_callback);              if (strcmp (base, ".") == 0 || strcmp (base, "..") == 0)
264                    base = basename (params.targets[i]);
265    
266                struct uar_file *file
267                    = uar_stream_add_entry (uar, base, params.rtargets[i], &stinfo);
268    
269              if (file == NULL || uar_has_error (uar))              if (file == NULL || uar_has_error (uar))
270                  {                  {
# Line 280  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      pinfo ("extracting: %s\n", uar_file_get_name (file));                            const char *uar_name __attribute__ ((unused)),
299                              const char *fs_name, enum uar_error_level level,
300                              const char *message)
301    {
302        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 294  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 302  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 347  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 357  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 378  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 398  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 413  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 422  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 436  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 446  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:
Legend:
Removed from v.32  
changed lines
  Added in v.40
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26