contrib/libarchive/archive_write_open_file.c

   1 /*-
   2  * Copyright (c) 2003-2004 Tim Kientzle
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer
  10  *    in this position and unchanged.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include "archive_platform.h"
  28 __FBSDID("$FreeBSD: src/lib/libarchive/archive_write_open_file.c,v 1.11 2005/03/13 01:47:31 kientzle Exp $");
  29
  30 #include <sys/stat.h>
  31 #include <errno.h>
  32 #include <fcntl.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <unistd.h>
  36
  37 #include "archive.h"
  38 #include "archive_private.h"
  39
  40 struct write_file_data {
  41         int             fd;
  42         char            filename[1];
  43 };
  44
  45 static int      file_close(struct archive *, void *);
  46 static int      file_open(struct archive *, void *);
  47 static ssize_t  file_write(struct archive *, void *, void *buff, size_t);
  48
  49 int
  50 archive_write_open_file(struct archive *a, const char *filename)
  51 {
  52         struct write_file_data *mine;
  53
  54         if (filename == NULL || filename[0] == '\0') {
  55                 mine = malloc(sizeof(*mine));
  56                 if (mine == NULL) {
  57                         archive_set_error(a, ENOMEM, "No memory");
  58                         return (ARCHIVE_FATAL);
  59                 }
  60                 mine->filename[0] = '\0'; /* Record that we're using stdout. */
  61         } else {
  62                 mine = malloc(sizeof(*mine) + strlen(filename));
  63                 if (mine == NULL) {
  64                         archive_set_error(a, ENOMEM, "No memory");
  65                         return (ARCHIVE_FATAL);
  66                 }
  67                 strcpy(mine->filename, filename);
  68         }
  69         mine->fd = -1;
  70         return (archive_write_open(a, mine,
  71                     file_open, file_write, file_close));
  72 }
  73
  74 static int
  75 file_open(struct archive *a, void *client_data)
  76 {
  77         int flags;
  78         struct write_file_data *mine;
  79         struct stat st, *pst;
  80
  81         pst = NULL;
  82         mine = client_data;
  83         flags = O_WRONLY | O_CREAT | O_TRUNC;
  84
  85         if (mine->filename[0] != '\0') {
  86                 mine->fd = open(mine->filename, flags, 0666);
  87
  88                 /*
  89                  * If client hasn't explicitly set the last block
  90                  * handling, then set it here: If the output is a
  91                  * block or character device, pad the last block,
  92                  * otherwise leave it unpadded.
  93                  */
  94                 if (mine->fd >= 0 && a->bytes_in_last_block < 0) {
  95                         if (fstat(mine->fd, &st) == 0) {
  96                                 pst = &st;
  97                                 if (S_ISCHR(st.st_mode) ||
  98                                     S_ISBLK(st.st_mode) ||
  99                                     S_ISFIFO(st.st_mode))
 100                                         /* Pad last block. */
 101                                         archive_write_set_bytes_in_last_block(a, 0);
 102                                 else
 103                                         /* Don't pad last block. */
 104                                         archive_write_set_bytes_in_last_block(a, 1);
 105                         }
 106                 }
 107         } else {
 108                 mine->fd = 1;
 109                 if (a->bytes_in_last_block < 0) /* Still default? */
 110                         /* Last block will be fully padded. */
 111                         archive_write_set_bytes_in_last_block(a, 0);
 112         }
 113
 114         if (mine->fd < 0) {
 115                 archive_set_error(a, errno, "Failed to open '%s'",
 116                     mine->filename);
 117                 return (ARCHIVE_FATAL);
 118         }
 119
 120         if (pst == NULL && fstat(mine->fd, &st) == 0)
 121                 pst = &st;
 122         if (pst == NULL) {
 123                 archive_set_error(a, errno, "Couldn't stat '%s'",
 124                     mine->filename);
 125                 return (ARCHIVE_FATAL);
 126         }
 127
 128         /*
 129          * If the output file is a regular file, don't add it to
 130          * itself.  If it's a device file, it's okay to add the device
 131          * entry to the output archive.
 132          */
 133         if (S_ISREG(pst->st_mode)) {
 134                 a->skip_file_dev = pst->st_dev;
 135                 a->skip_file_ino = pst->st_ino;
 136         }
 137
 138         return (ARCHIVE_OK);
 139 }
 140
 141 static ssize_t
 142 file_write(struct archive *a, void *client_data, void *buff, size_t length)
 143 {
 144         struct write_file_data  *mine;
 145         ssize_t bytesWritten;
 146
 147         mine = client_data;
 148         bytesWritten = write(mine->fd, buff, length);
 149         if (bytesWritten <= 0) {
 150                 archive_set_error(a, errno, "Write error");
 151                 return (-1);
 152         }
 153         return (bytesWritten);
 154 }
 155
 156 static int
 157 file_close(struct archive *a, void *client_data)
 158 {
 159         struct write_file_data  *mine = client_data;
 160
 161         (void)a; /* UNUSED */
 162         if (mine->filename[0] != '\0')
 163                 close(mine->fd);
 164         free(mine);
 165         return (ARCHIVE_OK);
 166 }