/[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 33 by rakinar2, Thu Aug 8 16:57:39 2024 UTC revision 40 by rakinar2, Sat Aug 10 14:44:20 2024 UTC
# Line 17  Line 17 
17  #include <sys/types.h>  #include <sys/types.h>
18  #include <time.h>  #include <time.h>
19  #include <unistd.h>  #include <unistd.h>
20    #include <utime.h>
21    
22  #if defined(__linux__)  #if defined(__linux__)
23  #    include <linux/limits.h>  #    include <linux/limits.h>
# Line 27  Line 28 
28  #endif  #endif
29    
30  const unsigned char UAR_MAGIC[] = { 0x99, 'U', 'A', 'R' };  const unsigned char UAR_MAGIC[] = { 0x99, 'U', 'A', 'R' };
31    const unsigned int UAR_MAX_SUPPORTED_VERSION = 0x01;
32    
33  struct uar_header  struct uar_header
34  {  {
# Line 51  struct uar_file Line 53  struct uar_file
53          {          {
54              char *loc;              char *loc;
55              uint64_t loclen;              uint64_t loclen;
56          } linkinfo;          } link;
57      } data;      } data;
58      mode_t mode;      mode_t mode;
59      time_t mtime;      time_t mtime;
# Line 65  struct uar_archive Line 67  struct uar_archive
67      struct uar_file **files;      struct uar_file **files;
68      struct uar_file *root;      struct uar_file *root;
69      enum uar_error ecode;      enum uar_error ecode;
     bool is_stream;  
     uint8_t *buffer; /* Deprecated */  
70      FILE *stream;      FILE *stream;
71        uint64_t stream_size;
72      int last_errno;      int last_errno;
73      char *err_file;      char *err_file;
74        uint64_t data_start;
75      uar_create_callback_t create_callback;      uar_create_callback_t create_callback;
76        uar_extract_callback_t extract_callback;
77  };  };
78    
79  void  void
# Line 80  uar_set_create_callback (struct uar_arch Line 83  uar_set_create_callback (struct uar_arch
83      uar->create_callback = callback;      uar->create_callback = callback;
84  }  }
85    
86    void
87    uar_set_extract_callback (struct uar_archive *uar,
88                              uar_extract_callback_t callback)
89    {
90        uar->extract_callback = callback;
91    }
92    
93  static void  static void
94  uar_set_error (struct uar_archive *uar, enum uar_error ecode,  uar_set_error (struct uar_archive *uar, enum uar_error ecode,
95                 const char *err_file)                 const char *err_file)
# Line 99  uar_strerror (const struct uar_archive * Line 109  uar_strerror (const struct uar_archive *
109              return "success";              return "success";
110          case UAR_INVALID_MAGIC:          case UAR_INVALID_MAGIC:
111              return "invalid archive magic";              return "invalid archive magic";
112            case UAR_INVALID_ARCHIVE:
113                return "invalid archive";
114            case UAR_UNSUPPORTED_VERSION:
115                return "archive version is not supported";
116          case UAR_INVALID_FILE:          case UAR_INVALID_FILE:
117              return "invalid file";              return "invalid file";
118          case UAR_INVALID_PATH:          case UAR_INVALID_PATH:
# Line 150  uar_create (void) Line 164  uar_create (void)
164      if (uar == NULL)      if (uar == NULL)
165          return NULL;          return NULL;
166    
     uar->is_stream = false;  
     uar->buffer = NULL;  
167      uar->ecode = UAR_SUCCESS;      uar->ecode = UAR_SUCCESS;
168      uar->header.size = 0;      uar->header.size = 0;
169      memcpy (uar->header.magic, UAR_MAGIC, 4);      memcpy (uar->header.magic, UAR_MAGIC, 4);
# Line 161  uar_create (void) Line 173  uar_create (void)
173      uar->files = NULL;      uar->files = NULL;
174      uar->stream = NULL;      uar->stream = NULL;
175      uar->root = NULL;      uar->root = NULL;
176        uar->stream_size = 0;
177      uar->last_errno = 0;      uar->last_errno = 0;
178      uar->err_file = NULL;      uar->err_file = NULL;
179    
# Line 181  uar_initialize_root (struct uar_archive Line 194  uar_initialize_root (struct uar_archive
194      root->type = UF_DIR;      root->type = UF_DIR;
195      root->mode = S_IFDIR | 0755;      root->mode = S_IFDIR | 0755;
196      root->mtime = time (NULL);      root->mtime = time (NULL);
197        root->uid = getuid ();
198        root->gid = getgid ();
199    
200      if (!uar_add_file_entry (uar, root))      if (!uar_add_file_entry (uar, root))
201          {          {
# Line 205  uar_initialize (struct uar_archive *uar) Line 220  uar_initialize (struct uar_archive *uar)
220  bool  bool
221  uar_stream_write (struct uar_archive *uar, const char *filename)  uar_stream_write (struct uar_archive *uar, const char *filename)
222  {  {
223      if (uar == NULL || !uar->is_stream || uar->stream == NULL)      if (uar == NULL || uar->stream == NULL)
224          return false;          return false;
225    
226      FILE *stream = fopen (filename, "wb");      FILE *stream = fopen (filename, "wb");
# Line 236  uar_stream_write (struct uar_archive *ua Line 251  uar_stream_write (struct uar_archive *ua
251                      fclose (stream);                      fclose (stream);
252                      return false;                      return false;
253                  }                  }
254    
255                if (file->type == UF_LINK)
256                    {
257                        if (fwrite (file->data.link.loc, 1, file->data.link.loclen,
258                                    stream)
259                            != file->data.link.loclen)
260                            {
261                                uar_set_error (uar, UAR_SYSCALL_ERROR, file->name);
262                                fclose (stream);
263                                return false;
264                            }
265                    }
266          }          }
267    
268      uar->stream = freopen (NULL, "rb", uar->stream);      uar->stream = freopen (NULL, "rb", uar->stream);
# Line 287  uar_stream_write (struct uar_archive *ua Line 314  uar_stream_write (struct uar_archive *ua
314                  size -= buf_size;                  size -= buf_size;
315          }          }
316    
317        free (buf);
318      fclose (stream);      fclose (stream);
319      return true;      return true;
320  }  }
321    
322  struct uar_archive *  struct uar_archive *
323  uar_create_stream (void)  uar_stream_create (void)
324  {  {
325      struct uar_archive *uar = uar_create ();      struct uar_archive *uar = uar_create ();
326      int cerrno;      int cerrno;
# Line 300  uar_create_stream (void) Line 328  uar_create_stream (void)
328      if (uar == NULL)      if (uar == NULL)
329          return NULL;          return NULL;
330    
     uar->is_stream = true;  
331      uar->stream = tmpfile ();      uar->stream = tmpfile ();
332    
333      if (uar->stream == NULL)      if (uar->stream == NULL)
# Line 315  uar_create_stream_error: Line 342  uar_create_stream_error:
342      cerrno = errno;      cerrno = errno;
343      uar_close (uar);      uar_close (uar);
344      errno = cerrno;      errno = cerrno;
345        uar = NULL;
346  uar_create_stream_ret:  uar_create_stream_ret:
347      return uar;      return uar;
348  }  }
# Line 324  uar_stream_add_file (struct uar_archive Line 352  uar_stream_add_file (struct uar_archive
352                       const char *fs_filename, struct stat *stinfo)                       const char *fs_filename, struct stat *stinfo)
353  {  {
354      assert (uar != NULL && "uar is NULL");      assert (uar != NULL && "uar is NULL");
     assert (uar->is_stream && "uar is not in stream mode");  
355      assert (uar_filename != NULL && "uar_filename is NULL");      assert (uar_filename != NULL && "uar_filename is NULL");
356      assert (fs_filename != NULL && "fs_filename is NULL");      assert (fs_filename != NULL && "fs_filename is NULL");
357    
# Line 338  uar_stream_add_file (struct uar_archive Line 365  uar_stream_add_file (struct uar_archive
365      enum uar_error ecode = UAR_SUCCESS;      enum uar_error ecode = UAR_SUCCESS;
366      void *buffer = NULL;      void *buffer = NULL;
367      struct uar_file *file = NULL;      struct uar_file *file = NULL;
368        uint64_t uar_file_namelen = strlen (uar_filename);
369    
370        if (uar_file_namelen > PATH_MAX)
371            {
372                uar_set_error (uar, UAR_INVALID_PATH, fs_filename);
373                return NULL;
374            }
375    
376        bool contains_dot_dot
377            = (uar_file_namelen > 3 && uar_filename[0] == '.'
378               && uar_filename[1] == '.' && uar_filename[2] == '/');
379    
380        if ((uar_file_namelen > 2 && uar_filename[0] == '.'
381             && uar_filename[1] == '/')
382            || contains_dot_dot)
383            {
384                if (uar->create_callback != NULL)
385                    uar->create_callback (
386                        uar, NULL, uar_filename, fs_filename, UAR_ELEVEL_WARNING,
387                        contains_dot_dot ? "removing leading '..'"
388                                         : "removing leading '.'");
389    
390                uar_filename = uar_filename + 1 + (uar_file_namelen == 1);
391                uar_file_namelen -= 1 + (uar_file_namelen == 1);
392            }
393    
394      if (stinfo == NULL)      if (stinfo == NULL)
395          {          {
# Line 380  uar_stream_add_file (struct uar_archive Line 432  uar_stream_add_file (struct uar_archive
432    
433      fseek (stream, 0, SEEK_SET);      fseek (stream, 0, SEEK_SET);
434    
435      file = uar_file_create (uar_filename, 0, size, uar->header.size);      file = uar_file_create (uar_filename, uar_file_namelen, size,
436                                uar->header.size);
437    
438      if (file == NULL)      if (file == NULL)
439          {          {
# Line 513  uar_stream_add_dir (struct uar_archive * Line 566  uar_stream_add_dir (struct uar_archive *
566              struct uar_file *entry_file              struct uar_file *entry_file
567                  = uar_stream_add_entry (uar, uar_fullpath, fs_fullpath, NULL);                  = uar_stream_add_entry (uar, uar_fullpath, fs_fullpath, NULL);
568    
569              if (entry_file != NULL)              if (entry_file != NULL && entry_file->type != UF_LINK)
570                  size += entry_file->data.size;                  size += entry_file->data.size;
571    
572              free (fs_fullpath);              free (fs_fullpath);
# Line 565  uar_stream_add_link (struct uar_archive Line 618  uar_stream_add_link (struct uar_archive
618                  stinfo = &custom_stinfo;                  stinfo = &custom_stinfo;
619          }          }
620    
621        uint64_t uar_file_namelen = strlen (uar_name);
622    
623        bool contains_dot_dot = (uar_file_namelen > 3 && uar_name[0] == '.'
624                                 && uar_name[1] == '.' && uar_name[2] == '/');
625    
626        if ((uar_file_namelen > 2 && uar_name[0] == '.' && uar_name[1] == '/')
627            || contains_dot_dot)
628            {
629                if (uar->create_callback != NULL)
630                    uar->create_callback (
631                        uar, NULL, uar_name, fs_name, UAR_ELEVEL_WARNING,
632                        contains_dot_dot ? "removing leading '..'"
633                                         : "removing leading '.'");
634    
635                uar_name = uar_name + 1 + (uar_file_namelen == 1);
636                uar_file_namelen -= 1 + (uar_file_namelen == 1);
637            }
638    
639      file = uar_file_create (uar_name, 0, 0, uar->header.size);      file = uar_file_create (uar_name, 0, 0, uar->header.size);
640    
641      if (file == NULL)      if (file == NULL)
# Line 593  uar_stream_add_link (struct uar_archive Line 664  uar_stream_add_link (struct uar_archive
664              return NULL;              return NULL;
665          }          }
666    
667      file->data.linkinfo.loclen = link_len;      file->data.link.loclen = link_len;
668      file->data.linkinfo.loc = malloc (link_len + 1);      file->data.link.loc = malloc (link_len + 1);
669    
670      if (file->data.linkinfo.loc == NULL)      if (file->data.link.loc == NULL)
671          {          {
672              uar_set_error (uar, UAR_OUT_OF_MEMORY, fs_name);              uar_set_error (uar, UAR_OUT_OF_MEMORY, fs_name);
673              uar_file_destroy (file);              uar_file_destroy (file);
674              return NULL;              return NULL;
675          }          }
676    
677      memcpy (file->data.linkinfo.loc, link_buf, link_len);      memcpy (file->data.link.loc, link_buf, link_len);
678      file->data.linkinfo.loc[link_len] = 0;      file->data.link.loc[link_len] = 0;
679    
680      if (!uar_add_file_entry (uar, file))      if (!uar_add_file_entry (uar, file))
681          {          {
# Line 624  uar_stream_add_entry (struct uar_archive Line 695  uar_stream_add_entry (struct uar_archive
695                        const char *fs_name, struct stat *stinfo)                        const char *fs_name, struct stat *stinfo)
696  {  {
697      assert (uar != NULL && "uar is NULL");      assert (uar != NULL && "uar is NULL");
     assert (uar->is_stream && "uar is not in stream mode");  
698      assert (uar_name != NULL && "uar_name is NULL");      assert (uar_name != NULL && "uar_name is NULL");
699      assert (fs_name != NULL && "fs_name is NULL");      assert (fs_name != NULL && "fs_name is NULL");
700    
# Line 652  uar_stream_add_entry (struct uar_archive Line 722  uar_stream_add_entry (struct uar_archive
722                  }                  }
723          }          }
724      else if (S_ISDIR (stinfo->st_mode))      else if (S_ISDIR (stinfo->st_mode))
725          {          file = uar_stream_add_dir (uar, uar_name, fs_name, stinfo);
726              file = uar_stream_add_dir (uar, uar_name, fs_name, stinfo);  
727          }      else if (S_ISLNK (stinfo->st_mode))
728            file = uar_stream_add_link (uar, uar_name, fs_name, stinfo);
729      else      else
730          {          {
731              file = uar_stream_add_link (uar, uar_name, fs_name, stinfo);              uar_set_error (uar, UAR_INVALID_FILE, fs_name);
732                return NULL;
733          }          }
734    
735      if (file != NULL)      if (file != NULL)
# Line 671  uar_stream_add_entry (struct uar_archive Line 743  uar_stream_add_entry (struct uar_archive
743      return file;      return file;
744  }  }
745    
746    /* Validate the UAR archive header. */
747    bool
748    uar_stream_header_validate (struct uar_archive *uar)
749    {
750        /* Compare magic to ensure it's a valid UAR archive. */
751        if (memcmp (uar->header.magic, UAR_MAGIC, sizeof (UAR_MAGIC)) != 0)
752            {
753                uar_set_error (uar, UAR_INVALID_MAGIC, NULL);
754                return false;
755            }
756    
757        /* Check if the version is supported. */
758        if (uar->header.version > UAR_MAX_SUPPORTED_VERSION)
759            {
760                uar_set_error (uar, UAR_UNSUPPORTED_VERSION, NULL);
761                return false;
762            }
763    
764        /* Check if the data block size is valid, to prevent buffer overflow. If
765           it's larger than the stream  size, it's invalid. This could be because
766           the archive is corrupted, or it's a malicious archive. */
767        if (uar->header.size > (uar->stream_size - sizeof (struct uar_header)))
768            {
769                uar_set_error (uar, UAR_INVALID_ARCHIVE, NULL);
770                return false;
771            }
772    
773        /* At the moment, UAR doesn't support any flags. */
774        if (uar->header.flags != 0)
775            {
776                uar_set_error (uar, UAR_INVALID_ARCHIVE, NULL);
777                return false;
778            }
779    
780        /* Check if the file is big enough to hold n number of files. */
781        if (uar->header.nfiles * sizeof (struct uar_file) > uar->header.size)
782            {
783                uar_set_error (uar, UAR_INVALID_ARCHIVE, NULL);
784                return false;
785            }
786    
787        return true;
788    }
789    
790  struct uar_archive *  struct uar_archive *
791  uar_open (const char *filename)  uar_stream_open (const char *filename)
792  {  {
793      struct uar_archive *uar = NULL;      struct uar_archive *uar;
794      FILE *stream = NULL;      FILE *stream = fopen (filename, "rb");
795      int cerrno;  
796        if (stream == NULL)
797            return NULL;
798    
     errno = 0;  
799      uar = uar_create ();      uar = uar_create ();
800    
801      if (uar == NULL)      if (uar == NULL)
802          return NULL;          return NULL;
803    
804      stream = fopen (filename, "rb");      uar->stream = stream;
805    
806      if (stream == NULL)      fseek (stream, 0, SEEK_END);
807        long size = ftell (stream);
808    
809        if (size < 0 || size > INT64_MAX)
810          {          {
811              uar_set_error (uar, UAR_IO_ERROR, NULL);              uar_set_error (uar, UAR_SYSCALL_ERROR, NULL);
812              goto uar_open_ret;              return uar;
813          }          }
814    
     fseek (stream, 0, SEEK_END);  
     size_t size = ftell (stream);  
815      fseek (stream, 0, SEEK_SET);      fseek (stream, 0, SEEK_SET);
816    
817      if (fread (&uar->header, sizeof (struct uar_header), 1, stream) != 1)      if (((size_t) size) < sizeof (struct uar_header))
818          {          {
819              uar_set_error (uar, UAR_IO_ERROR, NULL);              uar_set_error (uar, UAR_INVALID_ARCHIVE, NULL);
820              goto uar_open_ret;              return uar;
821          }          }
822    
823      if (memcmp (uar->header.magic, UAR_MAGIC, 4) != 0)      if (fread (&uar->header, 1, sizeof (struct uar_header), stream)
824            != sizeof (struct uar_header))
825          {          {
826              uar_set_error (uar, UAR_INVALID_MAGIC, NULL);              uar_set_error (uar, UAR_SYSCALL_ERROR, NULL);
827              goto uar_open_ret;              return uar;
828          }          }
829    
830      uint64_t filearr_size = uar->header.nfiles * sizeof (struct uar_file);      uar->stream_size = size;
831    
832      if (filearr_size > size)      if (!uar_stream_header_validate (uar))
833          {          return uar;
             uar_set_error (uar, UAR_IO_ERROR, NULL);  
             goto uar_open_ret;  
         }  
   
     if (uar->header.size > size)  
         {  
             uar_set_error (uar, UAR_IO_ERROR, NULL);  
             goto uar_open_ret;  
         }  
834    
835      uar->files = calloc (uar->header.nfiles, sizeof (struct uar_file *));      uar->files = calloc (uar->header.nfiles, sizeof (struct uar_file *));
836    
837      if (uar->files == NULL)      if (uar->files == NULL)
838          {          {
839              uar_set_error (uar, UAR_OUT_OF_MEMORY, NULL);              uar_set_error (uar, UAR_OUT_OF_MEMORY, NULL);
840              goto uar_open_ret;              return uar;
841          }          }
842    
843        uint64_t file_block_size
844            = sizeof (struct uar_header)
845              + (uar->header.nfiles * sizeof (struct uar_file));
846        uint64_t data_block_start = file_block_size;
847    
848      for (uint64_t i = 0; i < uar->header.nfiles; i++)      for (uint64_t i = 0; i < uar->header.nfiles; i++)
849          {          {
850              struct uar_file *file = malloc (sizeof (struct uar_file));              struct uar_file *file = malloc (sizeof (struct uar_file));
# Line 737  uar_open (const char *filename) Line 852  uar_open (const char *filename)
852              if (file == NULL)              if (file == NULL)
853                  {                  {
854                      uar_set_error (uar, UAR_OUT_OF_MEMORY, NULL);                      uar_set_error (uar, UAR_OUT_OF_MEMORY, NULL);
855                      goto uar_open_ret;                      return uar;
856                  }                  }
857    
858              if (fread (file, sizeof (struct uar_file), 1, stream) != 1)              if (fread (file, 1, sizeof (struct uar_file), stream)
859                    != sizeof (struct uar_file))
860                  {                  {
861                      uar_set_error (uar, UAR_IO_ERROR, NULL);                      uar_set_error (uar, UAR_SYSCALL_ERROR, NULL);
862                      goto uar_open_ret;                      free (file);
863                        return uar;
864                  }                  }
865    
866              if (file->namelen > PATH_MAX)              /* Right after the file structure, the name of the file is stored,
867                   with the length of the name stored in the namelen field.
868                   First, we need to check if the namelen is valid.
869                 */
870    
871                if (file->namelen > PATH_MAX || file->namelen == 0
872                    || file_block_size + file->namelen > ((uint64_t) size))
873                  {                  {
874                      uar_set_error (uar, UAR_INVALID_PATH, NULL);                      /* At a later stage, we might want to rather call a callback
875                      goto uar_open_ret;                         function instead. */
876                        uar_set_error (uar, UAR_INVALID_ARCHIVE, NULL);
877                        free (file);
878                        return uar;
879                  }                  }
880    
881                data_block_start += file->namelen;
882              file->name = malloc (file->namelen + 1);              file->name = malloc (file->namelen + 1);
883    
884              if (file->name == NULL)              if (file->name == NULL)
885                  {                  {
886                      uar_set_error (uar, UAR_OUT_OF_MEMORY, NULL);                      uar_set_error (uar, UAR_OUT_OF_MEMORY, NULL);
887                      goto uar_open_ret;                      free (file);
888                        return uar;
889                  }                  }
890    
891              if (fread (file->name, 1, file->namelen, stream) != file->namelen)              if (fread (file->name, 1, file->namelen, stream) != file->namelen)
892                  {                  {
893                      uar_set_error (uar, UAR_IO_ERROR, file->name);                      uar_set_error (uar, UAR_SYSCALL_ERROR, NULL);
894                      goto uar_open_ret;                      free (file->name);
895                        free (file);
896                        return uar;
897                  }                  }
898    
899              file->name[file->namelen] = 0;              file->name[file->namelen] = 0;
900    
901                /* Next, we need to check if the file is a link. If it is, we need
902                   to read the link location. */
903    
904                if (file->type == UF_LINK)
905                    {
906                        if (file->data.link.loclen > PATH_MAX
907                            || file_block_size + file->data.link.loclen
908                                   > ((uint64_t) size))
909                            {
910                                uar_set_error (uar, UAR_INVALID_ARCHIVE, NULL);
911                                free (file->name);
912                                free (file);
913                                return uar;
914                            }
915    
916                        data_block_start += file->data.link.loclen;
917                        file->data.link.loc = malloc (file->data.link.loclen + 1);
918    
919                        if (file->data.link.loc == NULL)
920                            {
921                                uar_set_error (uar, UAR_OUT_OF_MEMORY, NULL);
922                                free (file->name);
923                                free (file);
924                                return uar;
925                            }
926    
927                        if (fread (file->data.link.loc, 1, file->data.link.loclen,
928                                   stream)
929                            != file->data.link.loclen)
930                            {
931                                uar_set_error (uar, UAR_SYSCALL_ERROR, NULL);
932                                free (file->name);
933                                free (file->data.link.loc);
934                                free (file);
935                                return uar;
936                            }
937    
938                        file->data.link.loc[file->data.link.loclen] = 0;
939                    }
940    
941              uar->files[i] = file;              uar->files[i] = file;
942          }          }
943    
944      uar->buffer = malloc (uar->header.size + 1);      uar->data_start = data_block_start;
945        return uar;
946    }
947    
948    static bool
949    uar_stream_extract_file (struct uar_archive *uar, struct uar_file *file,
950                             const char *path)
951    {
952        FILE *stream = fopen (path, "wb");
953        uint8_t buffer[1024];
954        uint64_t size = file->data.size;
955    
956      if (uar->buffer == NULL)      if (stream == NULL)
957          {          {
958              uar_set_error (uar, UAR_OUT_OF_MEMORY, NULL);              uar_set_error (uar, UAR_SYSCALL_ERROR, path);
959              goto uar_open_ret;              perror ("fopen");
960    
961                if (uar->extract_callback != NULL)
962                    uar->extract_callback (uar, file, file->name, path,
963                                           UAR_ELEVEL_WARNING, strerror (errno));
964    
965                return false;
966          }          }
967    
968      if (fread (uar->buffer, 1, uar->header.size, stream) != uar->header.size)      if (fseek (uar->stream, uar->data_start + file->offset, SEEK_SET) != 0)
969          {          {
970              uar_set_error (uar, UAR_IO_ERROR, NULL);              uar_set_error (uar, UAR_SYSCALL_ERROR, path);
971              goto uar_open_ret;  
972                if (uar->extract_callback != NULL)
973                    uar->extract_callback (uar, file, file->name, path,
974                                           UAR_ELEVEL_WARNING, strerror (errno));
975    
976                fclose (stream);
977                return false;
978            }
979    
980        while (size > 0)
981            {
982                size_t read_size = size > sizeof (buffer) ? sizeof (buffer) : size;
983    
984                if (fread (buffer, 1, read_size, uar->stream) != read_size)
985                    {
986                        uar_set_error (uar, UAR_SYSCALL_ERROR, path);
987    
988                        if (uar->extract_callback != NULL)
989                            uar->extract_callback (uar, file, file->name, path,
990                                                   UAR_ELEVEL_WARNING,
991                                                   strerror (errno));
992    
993                        fclose (stream);
994                        return false;
995                    }
996    
997                if (fwrite (buffer, 1, read_size, stream) != read_size)
998                    {
999                        uar_set_error (uar, UAR_SYSCALL_ERROR, path);
1000    
1001                        if (uar->extract_callback != NULL)
1002                            uar->extract_callback (uar, file, file->name, path,
1003                                                   UAR_ELEVEL_WARNING,
1004                                                   strerror (errno));
1005    
1006                        fclose (stream);
1007                        return false;
1008                    }
1009    
1010                size -= read_size;
1011            }
1012    
1013        if (fchmod (fileno (stream), file->mode) != 0)
1014            {
1015                uar_set_error (uar, UAR_SYSCALL_ERROR, path);
1016    
1017                if (uar->extract_callback != NULL)
1018                    uar->extract_callback (uar, file, file->name, path,
1019                                           UAR_ELEVEL_WARNING, strerror (errno));
1020    
1021                fclose (stream);
1022                return false;
1023          }          }
1024    
 uar_open_ret:  
     cerrno = errno;  
1025      fclose (stream);      fclose (stream);
1026      errno = cerrno;      return true;
1027      return uar;  }
1028    
1029    bool
1030    uar_stream_extract (struct uar_archive *uar, const char *dest)
1031    {
1032        for (uint64_t i = 0; i < uar->header.nfiles; i++)
1033            {
1034                struct uar_file *file = uar->files[i];
1035                char *name = file->name;
1036                size_t diff = 0;
1037                bool is_root = strcmp (file->name, "/") == 0;
1038    
1039                if (!is_root)
1040                    {
1041                        if (name[0] == '/')
1042                            diff += 1;
1043    
1044                        if (strncmp (name, "./", 2) == 0)
1045                            diff += 2;
1046                        else if (strncmp (name, "../", 3) == 0)
1047                            diff += 3;
1048                        else if (strcmp (name, "..") == 0)
1049                            diff += 2;
1050                        else if (strcmp (name, ".") == 0)
1051                            diff += 1;
1052                    }
1053    
1054                char *path
1055                    = is_root ? (char *) dest
1056                              : path_concat (dest, file->name + diff, strlen (dest),
1057                                             file->namelen - diff);
1058    
1059                if (path == NULL)
1060                    {
1061                        uar_set_error (uar, UAR_OUT_OF_MEMORY, file->name);
1062                        return false;
1063                    }
1064    
1065                if (!is_root)
1066                    {
1067                        switch (file->type)
1068                            {
1069                            case UF_FILE:
1070                                if (!uar_stream_extract_file (uar, file, path))
1071                                    {
1072                                        free (path);
1073                                        return false;
1074                                    }
1075                                break;
1076                            case UF_DIR:
1077                                if (mkdir (path, file->mode) != 0)
1078                                    {
1079                                        uar_set_error (uar, UAR_SYSCALL_ERROR,
1080                                                       path);
1081    
1082                                        if (uar->extract_callback != NULL)
1083                                            uar->extract_callback (
1084                                                uar, file, file->name, path,
1085                                                UAR_ELEVEL_WARNING,
1086                                                strerror (errno));
1087    
1088                                        free (path);
1089                                        return false;
1090                                    }
1091                                break;
1092                            case UF_LINK:
1093                                if (symlink (file->data.link.loc, path) != 0)
1094                                    {
1095                                        uar_set_error (uar, UAR_SYSCALL_ERROR,
1096                                                       path);
1097    
1098                                        if (uar->extract_callback != NULL)
1099                                            uar->extract_callback (
1100                                                uar, file, file->name, path,
1101                                                UAR_ELEVEL_WARNING,
1102                                                strerror (errno));
1103    
1104                                        free (path);
1105                                        return false;
1106                                    }
1107                                break;
1108                            default:
1109                                uar_set_error (uar, UAR_INVALID_FILE, file->name);
1110    
1111                                if (uar->extract_callback != NULL)
1112                                    uar->extract_callback (uar, file, file->name,
1113                                                           path, UAR_ELEVEL_WARNING,
1114                                                           strerror (errno));
1115    
1116                                free (path);
1117                                return false;
1118                            }
1119                    }
1120    
1121                struct utimbuf times
1122                    = { .actime = time (NULL), .modtime = file->mtime };
1123    
1124                if (utime (path, &times) != 0)
1125                    {
1126                        uar_set_error (uar, UAR_SYSCALL_ERROR, path);
1127    
1128                        if (uar->extract_callback != NULL)
1129                            uar->extract_callback (uar, file, file->name, path,
1130                                                   UAR_ELEVEL_WARNING,
1131                                                   strerror (errno));
1132    
1133                        if (!is_root)
1134                            free (path);
1135    
1136                        return false;
1137                    }
1138    
1139                if (chown (path, file->uid, file->gid) != 0)
1140                    {
1141                        uar_set_error (uar, UAR_SYSCALL_ERROR, path);
1142    
1143                        if (uar->extract_callback != NULL)
1144                            uar->extract_callback (uar, file, file->name, path,
1145                                                   UAR_ELEVEL_WARNING,
1146                                                   strerror (errno));
1147    
1148                        if (!is_root)
1149                            free (path);
1150    
1151                        return false;
1152                    }
1153    
1154                if (uar->extract_callback != NULL)
1155                    uar->extract_callback (uar, file, file->name, path,
1156                                           UAR_ELEVEL_NONE, NULL);
1157    
1158                if (!is_root)
1159                    free (path);
1160            }
1161    
1162        return true;
1163  }  }
1164    
1165  void  void
# Line 798  uar_file_destroy (struct uar_file *file) Line 1169  uar_file_destroy (struct uar_file *file)
1169          return;          return;
1170    
1171      if (file->type == UF_LINK)      if (file->type == UF_LINK)
1172          free (file->data.linkinfo.loc);          free (file->data.link.loc);
1173    
1174      free (file->name);      free (file->name);
1175      free (file);      free (file);
# Line 810  uar_close (struct uar_archive *uar) Line 1181  uar_close (struct uar_archive *uar)
1181      if (uar == NULL)      if (uar == NULL)
1182          return;          return;
1183    
1184      if (uar->is_stream)      fclose (uar->stream);
         fclose (uar->stream);  
     else  
         free (uar->buffer);  
1185    
1186      for (uint64_t i = 0; i < uar->header.nfiles; i++)      for (uint64_t i = 0; i < uar->header.nfiles; i++)
1187          {          {
# Line 904  uar_file_create (const char *name, uint6 Line 1272  uar_file_create (const char *name, uint6
1272      return file;      return file;
1273  }  }
1274    
1275  struct uar_file *  void
1276  uar_add_file (struct uar_archive *restrict uar, const char *name,  uar_file_set_mode (struct uar_file *file, mode_t mode)
               const char *path, struct stat *stinfo)  
1277  {  {
1278      assert (uar != NULL && "uar is NULL");      file->mode = mode;
     assert (name != NULL && "name is NULL");  
     assert (path != NULL && "path is NULL");  
     assert (!uar->is_stream && "uar in non-stream mode is not supported yet");  
   
     uint64_t namelen = strlen (name);  
     struct stat *file_stinfo = stinfo, st_stinfo = { 0 };  
   
     if (namelen >= PATH_MAX)  
         {  
             uar_set_error (uar, UAR_INVALID_PATH, path);  
             return NULL;  
         }  
   
     if (file_stinfo == NULL)  
         {  
             if (lstat (path, &st_stinfo) != 0)  
                 {  
                     uar_set_error (uar, UAR_IO_ERROR, path);  
                     return NULL;  
                 }  
   
             file_stinfo = &st_stinfo;  
         }  
   
     FILE *stream = fopen (path, "rb");  
   
     if (stream == NULL)  
         {  
             uar_set_error (uar, UAR_IO_ERROR, path);  
             return NULL;  
         }  
   
     fseek (stream, 0, SEEK_END);  
     long size = ftell (stream);  
   
     if (size < 0)  
         {  
             uar_set_error (uar, UAR_IO_ERROR, path);  
             fclose (stream);  
             return NULL;  
         }  
   
     fseek (stream, 0, SEEK_SET);  
   
     struct uar_file *file  
         = uar_file_create (name, namelen, size, uar->header.size);  
   
     if (file == NULL)  
         {  
             uar_set_error (uar, UAR_OUT_OF_MEMORY, path);  
             fclose (stream);  
             return NULL;  
         }  
   
     file->mtime = file_stinfo->st_mtime;  
     uar->header.size += size;  
   
     if (!uar_add_file_entry (uar, file))  
         {  
             uar_file_destroy (file);  
             fclose (stream);  
             return NULL;  
         }  
   
     uar->buffer = realloc (uar->buffer, uar->header.size);  
   
     if (uar->buffer == NULL)  
         {  
             uar_set_error (uar, UAR_OUT_OF_MEMORY, path);  
             fclose (stream);  
             return NULL;  
         }  
   
     if (size != 0 && fread (uar->buffer + file->offset, size, 1, stream) != 1)  
         {  
             uar_set_error (uar, UAR_IO_ERROR, path);  
             fclose (stream);  
             return NULL;  
         }  
   
     fclose (stream);  
     return file;  
1279  }  }
1280    
1281  struct uar_file *  static void
1282  uar_add_dir (struct uar_archive *uar, const char *dname, const char *path,  uar_debug_print_file_contents (const struct uar_archive *uar,
1283               bool (*callback) (struct uar_file *file, const char *fullname,                                 struct uar_file *file)
                                const char *fullpath))  
1284  {  {
1285      assert (uar != NULL && "uar is NULL");      printf ("    contents:\n");
1286      assert (dname != NULL && "dname is NULL");      printf ("==================\n");
1287      assert (path != NULL && "path is NULL");      fflush (stdout);
     assert (!uar->is_stream && "uar in non-stream mode is not supported yet");  
   
     char *name = (char *) dname;  
     bool free_name = false;  
     int cerrno;  
     uint64_t namelen;  
   
     if (strcmp (name, ".") == 0)  
         {  
             name = strdup ("/");  
             free_name = true;  
             namelen = 1;  
         }  
     else  
         namelen = strlen (name);  
   
     if (namelen >= PATH_MAX)  
         {  
             uar_set_error (uar, UAR_INVALID_PATH, path);  
             return NULL;  
         }  
   
     DIR *dir = opendir (path);  
     struct dirent *entry = NULL;  
   
     if (dir == NULL)  
         {  
             uar_set_error (uar, UAR_INVALID_FILE, path);  
             return NULL;  
         }  
   
     struct uar_file *dir_file  
         = uar_file_create (name, namelen, 0, uar->header.size);  
     uint64_t dir_size = 0;  
   
     dir_file->type = UF_DIR;  
1288    
1289      if (callback != NULL && !callback (dir_file, name, path))      if (fseek (uar->stream, uar->data_start + file->offset, SEEK_SET) != 0)
1290          {          {
1291              uar_set_error (uar, UAR_SUCCESS, NULL);              perror ("fseek");
1292              uar_file_destroy (dir_file);              return;
             return NULL;  
1293          }          }
1294    
1295      if (!uar_add_file_entry (uar, dir_file))      uint8_t buffer[1024];
         {  
             uar_file_destroy (dir_file);  
             return NULL;  
         }  
1296    
1297      while ((entry = readdir (dir)) != NULL)      while (file->data.size > 0)
1298          {          {
1299              if (strcmp (entry->d_name, ".") == 0              size_t size = file->data.size > sizeof (buffer) ? sizeof (buffer)
1300                  || strcmp (entry->d_name, "..") == 0)                                                              : file->data.size;
                 continue;  
   
             struct stat stinfo = { 0 };  
1301    
1302              if (256 + namelen >= PATH_MAX)              if (fread (buffer, 1, size, uar->stream) != size)
1303                  {                  {
1304                      uar_set_error (uar, UAR_INVALID_PATH, path);                      perror ("read");
1305                      uar_file_destroy (dir_file);                      return;
                     closedir (dir);  
                     return NULL;  
1306                  }                  }
1307    
1308              uint64_t dnamelen = strlen (entry->d_name);              for (size_t i = 0; i < size; i++)
   
             char *fullpath  
                 = path_concat (path, entry->d_name, strlen (path), dnamelen);  
             assert (fullpath != NULL);  
   
             char *fullname  
                 = path_concat (name, entry->d_name, namelen, dnamelen);  
             assert (fullname != NULL);  
   
             if (lstat (fullpath, &stinfo) != 0)  
                 {  
                     uar_set_error (uar, UAR_IO_ERROR, fullpath);  
                     goto uar_add_dir_error;  
                 }  
   
             if (S_ISREG (stinfo.st_mode))  
                 {  
                     struct uar_file *file  
                         = uar_add_file (uar, fullname, fullpath, &stinfo);  
   
                     if (file == NULL)  
                         {  
                             goto uar_add_dir_error;  
                         }  
   
                     if (callback != NULL  
                         && !callback (file, fullname, fullpath))  
                         {  
                             uar_set_error (uar, UAR_SUCCESS, NULL);  
                             goto uar_add_dir_error;  
                         }  
   
                     file->mode = stinfo.st_mode;  
                     dir_size += file->data.size;  
                 }  
             else if (S_ISDIR (stinfo.st_mode))  
1309                  {                  {
1310                      struct uar_file *direntry                      if (buffer[i] == '\n')
1311                          = uar_add_dir (uar, fullname, fullpath, callback);                          putchar ('\n');
1312                        else
1313                      if (direntry == NULL)                          putchar (buffer[i]);
                         {  
                             goto uar_add_dir_error;  
                         }  
   
                     direntry->mode = stinfo.st_mode;  
                     dir_size += direntry->data.size;  
1314                  }                  }
             else  
                 assert (false && "Not supported");  
   
             free (fullpath);  
             free (fullname);  
1315    
1316              continue;              file->data.size -= size;
   
         uar_add_dir_error:  
             cerrno = errno;  
             uar_file_destroy (dir_file);  
             free (fullpath);  
             free (fullname);  
             errno = cerrno;  
             goto uar_add_dir_end;  
         }  
   
     dir_file->data.size = dir_size;  
   
 uar_add_dir_end:  
     cerrno = errno;  
     closedir (dir);  
   
     if (free_name)  
         free (name);  
   
     errno = cerrno;  
     return dir_file;  
 }  
   
 void  
 uar_file_set_mode (struct uar_file *file, mode_t mode)  
 {  
     file->mode = mode;  
 }  
   
 static void  
 uar_debug_print_file_contents (const struct uar_archive *uar,  
                                struct uar_file *file)  
 {  
     printf ("    contents:\n");  
     printf ("==================\n");  
     fflush (stdout);  
   
     ssize_t size  
         = write (STDOUT_FILENO, uar->buffer + file->offset, file->data.size);  
   
     if (size == -1 || ((uint64_t) size) != file->data.size)  
         {  
             perror ("write");  
             return;  
1317          }          }
1318    
1319      putchar ('\n');      putchar ('\n');
# Line 1183  uar_debug_print (const struct uar_archiv Line 1330  uar_debug_print (const struct uar_archiv
1330      printf ("  flags: %u\n", uar->header.flags);      printf ("  flags: %u\n", uar->header.flags);
1331      printf ("  nfiles: %lu\n", uar->header.nfiles);      printf ("  nfiles: %lu\n", uar->header.nfiles);
1332      printf ("  size: %lu\n", uar->header.size);      printf ("  size: %lu\n", uar->header.size);
     printf ("  stream?: %i\n", uar->is_stream);  
1333    
1334      for (uint64_t i = 0; i < uar->header.nfiles; i++)      for (uint64_t i = 0; i < uar->header.nfiles; i++)
1335          {          {
# Line 1203  uar_debug_print (const struct uar_archiv Line 1349  uar_debug_print (const struct uar_archiv
1349              printf ("    mode: %04o\n", file->mode);              printf ("    mode: %04o\n", file->mode);
1350    
1351              if (file->type == UF_LINK)              if (file->type == UF_LINK)
1352                  printf ("    points to: %s\n", file->data.linkinfo.loc);                  printf ("    points to: %s\n", file->data.link.loc);
1353              else              else
1354                  printf ("    size: %lu\n", file->data.size);                  printf ("    size: %lu\n", file->data.size);
1355    
# Line 1213  uar_debug_print (const struct uar_archiv Line 1359  uar_debug_print (const struct uar_archiv
1359  }  }
1360    
1361  bool  bool
1362  uar_write (struct uar_archive *uar, const char *filename)  uar_stream_iterate (struct uar_archive *uar,
1363  {                      bool (*callback) (struct uar_file *file, void *data),
1364      FILE *stream = fopen (filename, "wb");                      void *data)
   
     if (stream == NULL)  
         {  
             uar_set_error (uar, UAR_IO_ERROR, filename);  
             return false;  
         }  
   
     if (fwrite (&uar->header, sizeof (struct uar_header), 1, stream) != 1)  
         {  
             uar_set_error (uar, UAR_IO_ERROR, filename);  
             fclose (stream);  
             return false;  
         }  
   
     for (uint64_t i = 0; i < uar->header.nfiles; i++)  
         {  
             struct uar_file *file = uar->files[i];  
   
             if (fwrite (file, sizeof (struct uar_file), 1, stream) != 1)  
                 {  
                     uar_set_error (uar, UAR_IO_ERROR, file->name);  
                     fclose (stream);  
                     return false;  
                 }  
   
             if (fwrite (file->name, 1, file->namelen, stream) != file->namelen)  
                 {  
                     uar_set_error (uar, UAR_IO_ERROR, file->name);  
                     fclose (stream);  
                     return false;  
                 }  
         }  
   
     if (fwrite (uar->buffer, 1, uar->header.size, stream) != uar->header.size)  
         {  
             uar_set_error (uar, UAR_IO_ERROR, NULL);  
             fclose (stream);  
             return false;  
         }  
   
     fclose (stream);  
     return true;  
 }  
   
 bool  
 uar_extract (struct uar_archive *uar, const char *cwd,  
              bool (*callback) (struct uar_file *file))  
 {  
     if (cwd != NULL && chdir (cwd) != 0)  
         {  
             uar_set_error (uar, UAR_SYSTEM_ERROR, NULL);  
             return false;  
         }  
   
     for (uint64_t i = 0; i < uar->header.nfiles; i++)  
         {  
             struct uar_file *file = uar->files[i];  
   
             if (callback != NULL && !callback (file))  
                 return false;  
   
             char *name = file->name;  
   
             if (name[0] == '/')  
                 name += 2;  
   
             switch (file->type)  
                 {  
                 case UF_FILE:  
                     {  
                         FILE *stream = fopen (name, "wb");  
   
                         if (stream == NULL)  
                             {  
                                 uar_set_error (uar, UAR_IO_ERROR, name);  
                                 return false;  
                             }  
   
                         if (fwrite (uar->buffer + file->offset, 1,  
                                     file->data.size, stream)  
                             != file->data.size)  
                             {  
                                 uar_set_error (uar, UAR_IO_ERROR, name);  
                                 return false;  
                             }  
   
                         fchmod (fileno (stream), file->mode & 07777);  
                         fclose (stream);  
                     }  
                     break;  
   
                 case UF_DIR:  
                     if (file->namelen == 1 && file->name[0] == '/')  
                         continue;  
   
                     if (mkdir (name, file->mode) != 0)  
                         {  
                             uar_set_error (uar, UAR_SYSTEM_ERROR, name);  
                             return false;  
                         }  
   
                     break;  
   
                 default:  
                     assert (false && "unknown file type");  
                     return false;  
                 }  
         }  
   
     return true;  
 }  
   
 bool  
 uar_iterate (struct uar_archive *uar,  
              bool (*callback) (struct uar_file *file, void *data), void *data)  
1365  {  {
1366      for (uint64_t i = 0; i < uar->header.nfiles; i++)      for (uint64_t i = 0; i < uar->header.nfiles; i++)
1367          {          {
# Line 1392  const char * Line 1423  const char *
1423  uar_get_error_file (const struct uar_archive *uar)  uar_get_error_file (const struct uar_archive *uar)
1424  {  {
1425      return uar->err_file;      return uar->err_file;
1426    }
1427    
1428    uid_t
1429    uar_file_get_uid (const struct uar_file *file)
1430    {
1431        return file->uid;
1432    }
1433    
1434    gid_t
1435    uar_file_get_gid (const struct uar_file *file)
1436    {
1437        return file->gid;
1438  }  }
Legend:
Removed from v.33  
changed lines
  Added in v.40
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26