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

Diff of /trunk/uar/uar.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 36 by rakinar2, Thu Aug 8 19:13:26 2024 UTC
# Line 27  Line 27 
27  #endif  #endif
28    
29  const unsigned char UAR_MAGIC[] = { 0x99, 'U', 'A', 'R' };  const unsigned char UAR_MAGIC[] = { 0x99, 'U', 'A', 'R' };
30    const unsigned int UAR_MAX_SUPPORTED_VERSION = 0x01;
31    
32  struct uar_header  struct uar_header
33  {  {
# Line 37  struct uar_header Line 38  struct uar_header
38      uint64_t size;      uint64_t size;
39  } __attribute__ ((packed));  } __attribute__ ((packed));
40    
41    /* TODO: Fix alignment */
42  struct uar_file  struct uar_file
43  {  {
44      enum uar_file_type type;      enum uar_file_type type;
     int __pad1;  
45      char *name;      char *name;
46      uint64_t namelen;      uint64_t namelen;
47      uint64_t offset;      uint64_t offset;
# Line 51  struct uar_file Line 52  struct uar_file
52          {          {
53              char *loc;              char *loc;
54              uint64_t loclen;              uint64_t loclen;
55          } linkinfo;          } link;
56      } data;      } data;
57      mode_t mode;      mode_t mode;
58      time_t mtime;      time_t mtime;
59      int __pad2;      uid_t uid;
60        gid_t gid;
61  };  };
62    
63  struct uar_archive  struct uar_archive
# Line 67  struct uar_archive Line 69  struct uar_archive
69      bool is_stream;      bool is_stream;
70      uint8_t *buffer; /* Deprecated */      uint8_t *buffer; /* Deprecated */
71      FILE *stream;      FILE *stream;
72        uint64_t stream_size;
73      int last_errno;      int last_errno;
74      char *err_file;      char *err_file;
75        uar_create_callback_t create_callback;
76  };  };
77    
78    void
79    uar_set_create_callback (struct uar_archive *uar,
80                             uar_create_callback_t callback)
81    {
82        uar->create_callback = callback;
83    }
84    
85  static void  static void
86  uar_set_error (struct uar_archive *uar, enum uar_error ecode,  uar_set_error (struct uar_archive *uar, enum uar_error ecode,
87                 const char *err_file)                 const char *err_file)
# Line 90  uar_strerror (const struct uar_archive * Line 101  uar_strerror (const struct uar_archive *
101              return "success";              return "success";
102          case UAR_INVALID_MAGIC:          case UAR_INVALID_MAGIC:
103              return "invalid archive magic";              return "invalid archive magic";
104            case UAR_INVALID_ARCHIVE:
105                return "invalid archive";
106            case UAR_UNSUPPORTED_VERSION:
107                return "archive version is not supported";
108          case UAR_INVALID_FILE:          case UAR_INVALID_FILE:
109              return "invalid file";              return "invalid file";
110          case UAR_INVALID_PATH:          case UAR_INVALID_PATH:
# Line 152  uar_create (void) Line 167  uar_create (void)
167      uar->files = NULL;      uar->files = NULL;
168      uar->stream = NULL;      uar->stream = NULL;
169      uar->root = NULL;      uar->root = NULL;
170        uar->stream_size = 0;
171      uar->last_errno = 0;      uar->last_errno = 0;
172      uar->err_file = NULL;      uar->err_file = NULL;
173    
# Line 172  uar_initialize_root (struct uar_archive Line 188  uar_initialize_root (struct uar_archive
188      root->type = UF_DIR;      root->type = UF_DIR;
189      root->mode = S_IFDIR | 0755;      root->mode = S_IFDIR | 0755;
190      root->mtime = time (NULL);      root->mtime = time (NULL);
191        root->uid = getuid ();
192        root->gid = getgid ();
193    
194      if (!uar_add_file_entry (uar, root))      if (!uar_add_file_entry (uar, root))
195          {          {
# Line 227  uar_stream_write (struct uar_archive *ua Line 245  uar_stream_write (struct uar_archive *ua
245                      fclose (stream);                      fclose (stream);
246                      return false;                      return false;
247                  }                  }
248    
249                if (file->type == UF_LINK)
250                    {
251                        if (fwrite (file->data.link.loc, 1, file->data.link.loclen,
252                                    stream)
253                            != file->data.link.loclen)
254                            {
255                                uar_set_error (uar, UAR_SYSCALL_ERROR, file->name);
256                                fclose (stream);
257                                return false;
258                            }
259                    }
260          }          }
261    
262      uar->stream = freopen (NULL, "rb", uar->stream);      uar->stream = freopen (NULL, "rb", uar->stream);
# Line 278  uar_stream_write (struct uar_archive *ua Line 308  uar_stream_write (struct uar_archive *ua
308                  size -= buf_size;                  size -= buf_size;
309          }          }
310    
311        free (buf);
312      fclose (stream);      fclose (stream);
313      return true;      return true;
314  }  }
315    
316  struct uar_archive *  struct uar_archive *
317  uar_create_stream (void)  uar_stream_create (void)
318  {  {
319      struct uar_archive *uar = uar_create ();      struct uar_archive *uar = uar_create ();
320      int cerrno;      int cerrno;
# Line 306  uar_create_stream_error: Line 337  uar_create_stream_error:
337      cerrno = errno;      cerrno = errno;
338      uar_close (uar);      uar_close (uar);
339      errno = cerrno;      errno = cerrno;
340        uar = NULL;
341  uar_create_stream_ret:  uar_create_stream_ret:
342      return uar;      return uar;
343  }  }
# Line 329  uar_stream_add_file (struct uar_archive Line 361  uar_stream_add_file (struct uar_archive
361      enum uar_error ecode = UAR_SUCCESS;      enum uar_error ecode = UAR_SUCCESS;
362      void *buffer = NULL;      void *buffer = NULL;
363      struct uar_file *file = NULL;      struct uar_file *file = NULL;
364        uint64_t uar_file_namelen = strlen (uar_filename);
365    
366        if (uar_file_namelen > PATH_MAX)
367            {
368                uar_set_error (uar, UAR_INVALID_PATH, fs_filename);
369                return NULL;
370            }
371    
372        bool contains_dot_dot
373            = (uar_file_namelen > 3 && uar_filename[0] == '.'
374               && uar_filename[1] == '.' && uar_filename[2] == '/');
375    
376        if ((uar_file_namelen > 2 && uar_filename[0] == '.'
377             && uar_filename[1] == '/')
378            || contains_dot_dot)
379            {
380                if (uar->create_callback != NULL)
381                    uar->create_callback (
382                        uar, NULL, uar_filename, fs_filename, UAR_ELEVEL_WARNING,
383                        contains_dot_dot ? "removing leading '..'"
384                                         : "removing leading '.'");
385    
386                uar_filename = uar_filename + 1 + (uar_file_namelen == 1);
387                uar_file_namelen -= 1 + (uar_file_namelen == 1);
388            }
389    
390      if (stinfo == NULL)      if (stinfo == NULL)
391          {          {
392              if (lstat (fs_filename, &custom_stinfo) != 0)              if (lstat (fs_filename, &custom_stinfo) != 0)
393                  {                  {
394                      uar_set_error (uar, UAR_SYSCALL_ERROR, fs_filename);                      uar_set_error (uar, UAR_SYSCALL_ERROR, fs_filename);
395                      perror ("uar_stream_add_file::lstat");  
396                        if (uar->create_callback != NULL)
397                            uar->create_callback (uar, NULL, uar_filename,
398                                                  fs_filename, UAR_ELEVEL_WARNING,
399                                                  strerror (errno));
400    
401                      return NULL;                      return NULL;
402                  }                  }
403              else              else
# Line 347  uar_stream_add_file (struct uar_archive Line 409  uar_stream_add_file (struct uar_archive
409      if (stream == NULL)      if (stream == NULL)
410          {          {
411              uar_set_error (uar, UAR_SYSCALL_ERROR, fs_filename);              uar_set_error (uar, UAR_SYSCALL_ERROR, fs_filename);
412              perror ("uar_stream_add_file::fopen");  
413                if (uar->create_callback != NULL)
414                    uar->create_callback (uar, NULL, uar_filename, fs_filename,
415                                          UAR_ELEVEL_WARNING, strerror (errno));
416    
417              return NULL;              return NULL;
418          }          }
419    
# Line 362  uar_stream_add_file (struct uar_archive Line 428  uar_stream_add_file (struct uar_archive
428    
429      fseek (stream, 0, SEEK_SET);      fseek (stream, 0, SEEK_SET);
430    
431      file = uar_file_create (uar_filename, 0, size, uar->header.size);      file = uar_file_create (uar_filename, uar_file_namelen, size,
432                                uar->header.size);
433    
434      if (file == NULL)      if (file == NULL)
435          {          {
436              ecode = UAR_SYSCALL_ERROR;              ecode = UAR_SYSCALL_ERROR;
             perror ("uar_stream_add_file::uar_file_create");  
437              goto uar_stream_add_file_end;              goto uar_stream_add_file_end;
438          }          }
439    
# Line 379  uar_stream_add_file (struct uar_archive Line 445  uar_stream_add_file (struct uar_archive
445    
446      if (!uar_add_file_entry (uar, file))      if (!uar_add_file_entry (uar, file))
447          {          {
             perror ("uar_stream_add_file::uar_add_file_entry");  
448              uar_file_destroy (file);              uar_file_destroy (file);
449              fclose (stream);              fclose (stream);
450              return NULL;              return NULL;
# Line 405  uar_stream_add_file (struct uar_archive Line 470  uar_stream_add_file (struct uar_archive
470              goto uar_stream_add_file_end;              goto uar_stream_add_file_end;
471          }          }
472    
473        if (ecode == UAR_SUCCESS && uar->create_callback != NULL)
474            {
475                uar->create_callback (uar, file, uar_filename, fs_filename,
476                                      UAR_ELEVEL_NONE, NULL);
477            }
478    
479  uar_stream_add_file_end:  uar_stream_add_file_end:
480      if (ecode != UAR_SUCCESS && file != NULL)      if (ecode != UAR_SUCCESS && file != NULL)
481          uar_file_destroy (file);          uar_file_destroy (file);
# Line 419  uar_stream_add_file_end: Line 490  uar_stream_add_file_end:
490    
491  struct uar_file *  struct uar_file *
492  uar_stream_add_dir (struct uar_archive *uar, const char *uar_dirname,  uar_stream_add_dir (struct uar_archive *uar, const char *uar_dirname,
493                      const char *fs_dirname, struct stat *stinfo,                      const char *fs_dirname, struct stat *stinfo)
                     uar_callback_t callback)  
494  {  {
495      struct stat custom_stinfo = { 0 };      struct stat custom_stinfo = { 0 };
496      enum uar_error ecode = UAR_SUCCESS;      enum uar_error ecode = UAR_SUCCESS;
# Line 433  uar_stream_add_dir (struct uar_archive * Line 503  uar_stream_add_dir (struct uar_archive *
503              if (lstat (fs_dirname, &custom_stinfo) != 0)              if (lstat (fs_dirname, &custom_stinfo) != 0)
504                  {                  {
505                      uar_set_error (uar, UAR_SYSCALL_ERROR, fs_dirname);                      uar_set_error (uar, UAR_SYSCALL_ERROR, fs_dirname);
506    
507                        if (uar->create_callback != NULL)
508                            uar->create_callback (uar, NULL, uar_dirname,
509                                                  fs_dirname, UAR_ELEVEL_WARNING,
510                                                  strerror (errno));
511    
512                      return NULL;                      return NULL;
513                  }                  }
514              else              else
# Line 457  uar_stream_add_dir (struct uar_archive * Line 533  uar_stream_add_dir (struct uar_archive *
533              goto uar_stream_add_dir_error;              goto uar_stream_add_dir_error;
534          }          }
535    
     if (!callback (uar, file, uar_dirname, fs_dirname))  
         {  
             ecode = UAR_SUCCESS;  
             goto uar_stream_add_dir_error;  
         }  
   
536      dir = opendir (fs_dirname);      dir = opendir (fs_dirname);
537    
538      if (dir == NULL)      if (dir == NULL)
539          {          {
540                if (uar->create_callback != NULL)
541                    uar->create_callback (uar, NULL, uar_dirname, fs_dirname,
542                                          UAR_ELEVEL_WARNING, strerror (errno));
543    
544              ecode = UAR_SYSCALL_ERROR;              ecode = UAR_SYSCALL_ERROR;
545              goto uar_stream_add_dir_error;              goto uar_stream_add_dir_error;
546          }          }
# Line 485  uar_stream_add_dir (struct uar_archive * Line 559  uar_stream_add_dir (struct uar_archive *
559              char *uar_fullpath = path_concat (uar_dirname, entry->d_name,              char *uar_fullpath = path_concat (uar_dirname, entry->d_name,
560                                                strlen (uar_dirname), dname_len);                                                strlen (uar_dirname), dname_len);
561    
562              struct uar_file *entry_file = uar_stream_add_entry (              struct uar_file *entry_file
563                  uar, uar_fullpath, fs_fullpath, NULL, callback);                  = uar_stream_add_entry (uar, uar_fullpath, fs_fullpath, NULL);
564    
565              if (entry_file == NULL)              if (entry_file != NULL && entry_file->type != UF_LINK)
566                  {                  size += entry_file->data.size;
                     ecode = UAR_SYSCALL_ERROR;  
                     goto uar_stream_add_dir_ret;  
                 }  
567    
             size += entry_file->data.size;  
568              free (fs_fullpath);              free (fs_fullpath);
569              free (uar_fullpath);              free (uar_fullpath);
570          }          }
571    
572      file->data.size = size;      file->data.size = size;
573    
574        if (ecode == UAR_SUCCESS && uar->create_callback != NULL)
575            {
576                uar->create_callback (uar, file, uar_dirname, fs_dirname,
577                                      UAR_ELEVEL_NONE, NULL);
578            }
579    
580        goto uar_stream_add_dir_ret;
581  uar_stream_add_dir_error:  uar_stream_add_dir_error:
582      uar_set_error (uar, ecode, fs_dirname);      uar_set_error (uar, ecode, fs_dirname);
583  uar_stream_add_dir_ret:  uar_stream_add_dir_ret:
# Line 525  uar_stream_add_link (struct uar_archive Line 602  uar_stream_add_link (struct uar_archive
602              if (lstat (fs_name, &custom_stinfo) != 0)              if (lstat (fs_name, &custom_stinfo) != 0)
603                  {                  {
604                      uar_set_error (uar, UAR_SYSCALL_ERROR, fs_name);                      uar_set_error (uar, UAR_SYSCALL_ERROR, fs_name);
605    
606                        if (uar->create_callback != NULL)
607                            uar->create_callback (uar, NULL, uar_name, fs_name,
608                                                  UAR_ELEVEL_WARNING,
609                                                  strerror (errno));
610    
611                      return NULL;                      return NULL;
612                  }                  }
613              else              else
614                  stinfo = &custom_stinfo;                  stinfo = &custom_stinfo;
615          }          }
616    
617        uint64_t uar_file_namelen = strlen (uar_name);
618    
619        bool contains_dot_dot = (uar_file_namelen > 3 && uar_name[0] == '.'
620                                 && uar_name[1] == '.' && uar_name[2] == '/');
621    
622        if ((uar_file_namelen > 2 && uar_name[0] == '.' && uar_name[1] == '/')
623            || contains_dot_dot)
624            {
625                if (uar->create_callback != NULL)
626                    uar->create_callback (
627                        uar, NULL, uar_name, fs_name, UAR_ELEVEL_WARNING,
628                        contains_dot_dot ? "removing leading '..'"
629                                         : "removing leading '.'");
630    
631                uar_name = uar_name + 1 + (uar_file_namelen == 1);
632                uar_file_namelen -= 1 + (uar_file_namelen == 1);
633            }
634    
635      file = uar_file_create (uar_name, 0, 0, uar->header.size);      file = uar_file_create (uar_name, 0, 0, uar->header.size);
636    
637      if (file == NULL)      if (file == NULL)
# Line 551  uar_stream_add_link (struct uar_archive Line 652  uar_stream_add_link (struct uar_archive
652          {          {
653              uar_set_error (uar, UAR_SYSCALL_ERROR, fs_name);              uar_set_error (uar, UAR_SYSCALL_ERROR, fs_name);
654              uar_file_destroy (file);              uar_file_destroy (file);
655    
656                if (uar->create_callback != NULL)
657                    uar->create_callback (uar, NULL, uar_name, fs_name,
658                                          UAR_ELEVEL_WARNING, strerror (errno));
659    
660              return NULL;              return NULL;
661          }          }
662    
663      file->data.linkinfo.loclen = link_len;      file->data.link.loclen = link_len;
664      file->data.linkinfo.loc = malloc (link_len + 1);      file->data.link.loc = malloc (link_len + 1);
665    
666      if (file->data.linkinfo.loc == NULL)      if (file->data.link.loc == NULL)
667          {          {
668              uar_set_error (uar, UAR_OUT_OF_MEMORY, fs_name);              uar_set_error (uar, UAR_OUT_OF_MEMORY, fs_name);
669              uar_file_destroy (file);              uar_file_destroy (file);
670              return NULL;              return NULL;
671          }          }
672    
673      memcpy (file->data.linkinfo.loc, link_buf, link_len);      memcpy (file->data.link.loc, link_buf, link_len);
674      file->data.linkinfo.loc[link_len] = 0;      file->data.link.loc[link_len] = 0;
675    
676      if (!uar_add_file_entry (uar, file))      if (!uar_add_file_entry (uar, file))
677          {          {
# Line 573  uar_stream_add_link (struct uar_archive Line 679  uar_stream_add_link (struct uar_archive
679              return NULL;              return NULL;
680          }          }
681    
682        if (uar->create_callback != NULL && file != NULL)
683            uar->create_callback (uar, file, uar_name, fs_name, UAR_ELEVEL_NONE,
684                                  NULL);
685    
686      return file;      return file;
687  }  }
688    
689  struct uar_file *  struct uar_file *
690  uar_stream_add_entry (struct uar_archive *uar, const char *uar_name,  uar_stream_add_entry (struct uar_archive *uar, const char *uar_name,
691                        const char *fs_name, struct stat *stinfo,                        const char *fs_name, struct stat *stinfo)
                       uar_callback_t callback)  
692  {  {
693      assert (uar != NULL && "uar is NULL");      assert (uar != NULL && "uar is NULL");
694      assert (uar->is_stream && "uar is not in stream mode");      assert (uar->is_stream && "uar is not in stream mode");
# Line 608  uar_stream_add_entry (struct uar_archive Line 717  uar_stream_add_entry (struct uar_archive
717                  {                  {
718                      return NULL;                      return NULL;
719                  }                  }
   
             if (!callback (uar, file, uar_name, fs_name))  
                 {  
                     uar_set_error (uar, UAR_SUCCESS, fs_name);  
                     return NULL;  
                 }  
720          }          }
721      else if (S_ISDIR (stinfo->st_mode))      else if (S_ISDIR (stinfo->st_mode))
722            file = uar_stream_add_dir (uar, uar_name, fs_name, stinfo);
723    
724        else if (S_ISLNK (stinfo->st_mode))
725            file = uar_stream_add_link (uar, uar_name, fs_name, stinfo);
726        else
727          {          {
728              file              uar_set_error (uar, UAR_INVALID_FILE, fs_name);
729                  = uar_stream_add_dir (uar, uar_name, fs_name, stinfo, callback);              return NULL;
730          }          }
731      else  
732        if (file != NULL)
733          {          {
734              file = uar_stream_add_link (uar, uar_name, fs_name, stinfo);              file->mode = stinfo->st_mode;
735                file->mtime = stinfo->st_mtime;
736                file->uid = stinfo->st_uid;
737                file->gid = stinfo->st_gid;
738          }          }
739    
740      return file;      return file;
741  }  }
742    
743    /* Validate the UAR archive header. */
744    bool
745    uar_stream_header_validate (struct uar_archive *uar)
746    {
747        /* Compare magic to ensure it's a valid UAR archive. */
748        if (memcmp (uar->header.magic, UAR_MAGIC, sizeof (UAR_MAGIC)) != 0)
749            {
750                uar_set_error (uar, UAR_INVALID_MAGIC, NULL);
751                return false;
752            }
753    
754        /* Check if the version is supported. */
755        if (uar->header.version > UAR_MAX_SUPPORTED_VERSION)
756            {
757                uar_set_error (uar, UAR_UNSUPPORTED_VERSION, NULL);
758                return false;
759            }
760    
761        /* Check if the data block size is valid, to prevent buffer overflow. If
762           it's larger than the stream  size, it's invalid. This could be because
763           the archive is corrupted, or it's a malicious archive. */
764        if (uar->header.size > (uar->stream_size - sizeof (struct uar_header)))
765            {
766                uar_set_error (uar, UAR_INVALID_ARCHIVE, NULL);
767                return false;
768            }
769    
770        /* At the moment, UAR doesn't support any flags. */
771        if (uar->header.flags != 0)
772            {
773                uar_set_error (uar, UAR_INVALID_ARCHIVE, NULL);
774                return false;
775            }
776    
777        /* Check if the file is big enough to hold n number of files. */
778        if (uar->header.nfiles * sizeof (struct uar_file) > uar->header.size)
779            {
780                uar_set_error (uar, UAR_INVALID_ARCHIVE, NULL);
781                return false;
782            }
783    
784        return true;
785    }
786    
787    struct uar_archive *
788    uar_stream_open (const char *filename)
789    {
790        struct uar_archive *uar;
791        FILE *stream = fopen (filename, "rb");
792    
793        if (stream == NULL)
794            return NULL;
795    
796        uar = uar_create ();
797    
798        if (uar == NULL)
799            return NULL;
800    
801        uar->is_stream = true;
802        uar->stream = stream;
803    
804        fseek (stream, 0, SEEK_END);
805        long size = ftell (stream);
806    
807        if (size < 0 || size > INT64_MAX)
808            {
809                uar_set_error (uar, UAR_SYSCALL_ERROR, NULL);
810                return uar;
811            }
812    
813        fseek (stream, 0, SEEK_SET);
814    
815        if (((size_t) size) < sizeof (struct uar_header))
816            {
817                uar_set_error (uar, UAR_INVALID_ARCHIVE, NULL);
818                return uar;
819            }
820    
821        if (fread (&uar->header, 1, sizeof (struct uar_header), stream)
822            != sizeof (struct uar_header))
823            {
824                uar_set_error (uar, UAR_SYSCALL_ERROR, NULL);
825                return uar;
826            }
827    
828        uar->stream_size = size;
829    
830        if (!uar_stream_header_validate (uar))
831            return uar;
832    
833        uar->files = calloc (uar->header.nfiles, sizeof (struct uar_file *));
834    
835        if (uar->files == NULL)
836            {
837                uar_set_error (uar, UAR_OUT_OF_MEMORY, NULL);
838                return uar;
839            }
840    
841        uint64_t read_size = sizeof (struct uar_header)
842                             + (uar->header.nfiles * sizeof (struct uar_file));
843    
844        for (uint64_t i = 0; i < uar->header.nfiles; i++)
845            {
846                struct uar_file *file = malloc (sizeof (struct uar_file));
847    
848                if (file == NULL)
849                    {
850                        uar_set_error (uar, UAR_OUT_OF_MEMORY, NULL);
851                        return uar;
852                    }
853    
854                if (fread (file, 1, sizeof (struct uar_file), stream)
855                    != sizeof (struct uar_file))
856                    {
857                        uar_set_error (uar, UAR_SYSCALL_ERROR, NULL);
858                        free (file);
859                        return uar;
860                    }
861    
862                /* Right after the file structure, the name of the file is stored,
863                   with the length of the name stored in the namelen field.
864                   First, we need to check if the namelen is valid.
865                 */
866    
867                if (file->namelen > PATH_MAX || file->namelen == 0
868                    || read_size + file->namelen > ((uint64_t) size))
869                    {
870                        /* At a later stage, we might want to rather call a callback
871                           function instead. */
872                        uar_set_error (uar, UAR_INVALID_ARCHIVE, NULL);
873                        free (file);
874                        return uar;
875                    }
876    
877                file->name = malloc (file->namelen + 1);
878    
879                if (file->name == NULL)
880                    {
881                        uar_set_error (uar, UAR_OUT_OF_MEMORY, NULL);
882                        free (file);
883                        return uar;
884                    }
885    
886                if (fread (file->name, 1, file->namelen, stream) != file->namelen)
887                    {
888                        uar_set_error (uar, UAR_SYSCALL_ERROR, NULL);
889                        free (file->name);
890                        free (file);
891                        return uar;
892                    }
893    
894                file->name[file->namelen] = 0;
895    
896                /* Next, we need to check if the file is a link. If it is, we need
897                   to read the link location. */
898    
899                if (file->type == UF_LINK)
900                    {
901                        if (file->data.link.loclen > PATH_MAX
902                            || read_size + file->data.link.loclen
903                                   > ((uint64_t) size))
904                            {
905                                uar_set_error (uar, UAR_INVALID_ARCHIVE, NULL);
906                                free (file->name);
907                                free (file);
908                                return uar;
909                            }
910    
911                        file->data.link.loc = malloc (file->data.link.loclen + 1);
912    
913                        if (file->data.link.loc == NULL)
914                            {
915                                uar_set_error (uar, UAR_OUT_OF_MEMORY, NULL);
916                                free (file->name);
917                                free (file);
918                                return uar;
919                            }
920    
921                        if (fread (file->data.link.loc, 1, file->data.link.loclen,
922                                   stream)
923                            != file->data.link.loclen)
924                            {
925                                uar_set_error (uar, UAR_SYSCALL_ERROR, NULL);
926                                free (file->name);
927                                free (file->data.link.loc);
928                                free (file);
929                                return uar;
930                            }
931    
932                        file->data.link.loc[file->data.link.loclen] = 0;
933                    }
934    
935                uar->files[i] = file;
936            }
937    
938        return uar;
939    }
940    
941  struct uar_archive *  struct uar_archive *
942  uar_open (const char *filename)  uar_open (const char *filename)
943  {  {
# Line 755  uar_file_destroy (struct uar_file *file) Line 1065  uar_file_destroy (struct uar_file *file)
1065          return;          return;
1066    
1067      if (file->type == UF_LINK)      if (file->type == UF_LINK)
1068          free (file->data.linkinfo.loc);          free (file->data.link.loc);
1069    
1070      free (file->name);      free (file->name);
1071      free (file);      free (file);
# Line 837  uar_file_create (const char *name, uint6 Line 1147  uar_file_create (const char *name, uint6
1147      file->type = UF_FILE;      file->type = UF_FILE;
1148      file->mode = 0644;      file->mode = 0644;
1149      file->mtime = 0;      file->mtime = 0;
1150        file->uid = 0;
1151        file->gid = 0;
1152      file->name = malloc (namelen + 1);      file->name = malloc (namelen + 1);
1153    
1154      if (file->name == NULL)      if (file->name == NULL)
# Line 1158  uar_debug_print (const struct uar_archiv Line 1470  uar_debug_print (const struct uar_archiv
1470              printf ("    mode: %04o\n", file->mode);              printf ("    mode: %04o\n", file->mode);
1471    
1472              if (file->type == UF_LINK)              if (file->type == UF_LINK)
1473                  printf ("    points to: %s\n", file->data.linkinfo.loc);                  printf ("    points to: %s\n", file->data.link.loc);
1474              else              else
1475                  printf ("    size: %lu\n", file->data.size);                  printf ("    size: %lu\n", file->data.size);
1476    
# Line 1347  const char * Line 1659  const char *
1659  uar_get_error_file (const struct uar_archive *uar)  uar_get_error_file (const struct uar_archive *uar)
1660  {  {
1661      return uar->err_file;      return uar->err_file;
1662    }
1663    
1664    uid_t
1665    uar_file_get_uid (const struct uar_file *file)
1666    {
1667        return file->uid;
1668    }
1669    
1670    gid_t
1671    uar_file_get_gid (const struct uar_file *file)
1672    {
1673        return file->gid;
1674  }  }
Legend:
Removed from v.32  
changed lines
  Added in v.36
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26