Line data    Source code

       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * compress_none.c
       4             :  *   Routines for archivers to read or write an uncompressed stream.
       5             :  *
       6             :  * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  * IDENTIFICATION
      10             :  *     src/bin/pg_dump/compress_none.c
      11             :  *
      12             :  *-------------------------------------------------------------------------
      13             :  */
      14             : #include "postgres_fe.h"
      15             : #include <unistd.h>
      16             : 
      17             : #include "compress_none.h"
      18             : #include "pg_backup_utils.h"
      19             : 
      20             : /*----------------------
      21             :  * Compressor API
      22             :  *----------------------
      23             :  */
      24             : 
      25             : /*
      26             :  * Private routines
      27             :  */
      28             : 
      29             : static void
      30           0 : ReadDataFromArchiveNone(ArchiveHandle *AH, CompressorState *cs)
      31             : {
      32             :     size_t      cnt;
      33             :     char       *buf;
      34             :     size_t      buflen;
      35             : 
      36           0 :     buflen = DEFAULT_IO_BUFFER_SIZE;
      37           0 :     buf = pg_malloc(buflen);
      38             : 
      39           0 :     while ((cnt = cs->readF(AH, &buf, &buflen)))
      40             :     {
      41           0 :         ahwrite(buf, 1, cnt, AH);
      42             :     }
      43             : 
      44           0 :     free(buf);
      45           0 : }
      46             : 
      47             : 
      48             : static void
      49           0 : WriteDataToArchiveNone(ArchiveHandle *AH, CompressorState *cs,
      50             :                        const void *data, size_t dLen)
      51             : {
      52           0 :     cs->writeF(AH, data, dLen);
      53           0 : }
      54             : 
      55             : static void
      56           0 : EndCompressorNone(ArchiveHandle *AH, CompressorState *cs)
      57             : {
      58             :     /* no op */
      59           0 : }
      60             : 
      61             : /*
      62             :  * Public interface
      63             :  */
      64             : 
      65             : void
      66           0 : InitCompressorNone(CompressorState *cs,
      67             :                    const pg_compress_specification compression_spec)
      68             : {
      69           0 :     cs->readData = ReadDataFromArchiveNone;
      70           0 :     cs->writeData = WriteDataToArchiveNone;
      71           0 :     cs->end = EndCompressorNone;
      72             : 
      73           0 :     cs->compression_spec = compression_spec;
      74           0 : }
      75             : 
      76             : 
      77             : /*----------------------
      78             :  * Compress File API
      79             :  *----------------------
      80             :  */
      81             : 
      82             : /*
      83             :  * Private routines
      84             :  */
      85             : 
      86             : static size_t
      87       47110 : read_none(void *ptr, size_t size, CompressFileHandle *CFH)
      88             : {
      89       47110 :     FILE       *fp = (FILE *) CFH->private_data;
      90             :     size_t      ret;
      91             : 
      92       47110 :     ret = fread(ptr, 1, size, fp);
      93       47110 :     if (ferror(fp))
      94           0 :         pg_fatal("could not read from input file: %m");
      95             : 
      96       47110 :     return ret;
      97             : }
      98             : 
      99             : static void
     100     4414458 : write_none(const void *ptr, size_t size, CompressFileHandle *CFH)
     101             : {
     102             :     size_t      ret;
     103             : 
     104     4414458 :     errno = 0;
     105     4414458 :     ret = fwrite(ptr, 1, size, (FILE *) CFH->private_data);
     106     4414458 :     if (ret != size)
     107             :     {
     108           0 :         errno = (errno) ? errno : ENOSPC;
     109           0 :         pg_fatal("could not write to file: %m");
     110             :     }
     111     4414458 : }
     112             : 
     113             : static const char *
     114           0 : get_error_none(CompressFileHandle *CFH)
     115             : {
     116           0 :     return strerror(errno);
     117             : }
     118             : 
     119             : static char *
     120          24 : gets_none(char *ptr, int size, CompressFileHandle *CFH)
     121             : {
     122          24 :     return fgets(ptr, size, (FILE *) CFH->private_data);
     123             : }
     124             : 
     125             : static int
     126      418718 : getc_none(CompressFileHandle *CFH)
     127             : {
     128      418718 :     FILE       *fp = (FILE *) CFH->private_data;
     129             :     int         ret;
     130             : 
     131      418718 :     ret = fgetc(fp);
     132      418718 :     if (ret == EOF)
     133             :     {
     134           0 :         if (!feof(fp))
     135           0 :             pg_fatal("could not read from input file: %m");
     136             :         else
     137           0 :             pg_fatal("could not read from input file: end of file");
     138             :     }
     139             : 
     140      418718 :     return ret;
     141             : }
     142             : 
     143             : static bool
     144         820 : close_none(CompressFileHandle *CFH)
     145             : {
     146         820 :     FILE       *fp = (FILE *) CFH->private_data;
     147         820 :     int         ret = 0;
     148             : 
     149         820 :     CFH->private_data = NULL;
     150             : 
     151         820 :     if (fp)
     152             :     {
     153         820 :         errno = 0;
     154         820 :         ret = fclose(fp);
     155         820 :         if (ret != 0)
     156           0 :             pg_log_error("could not close file: %m");
     157             :     }
     158             : 
     159         820 :     return ret == 0;
     160             : }
     161             : 
     162             : static bool
     163          12 : eof_none(CompressFileHandle *CFH)
     164             : {
     165          12 :     return feof((FILE *) CFH->private_data) != 0;
     166             : }
     167             : 
     168             : static bool
     169         826 : open_none(const char *path, int fd, const char *mode, CompressFileHandle *CFH)
     170             : {
     171             :     Assert(CFH->private_data == NULL);
     172             : 
     173         826 :     if (fd >= 0)
     174         516 :         CFH->private_data = fdopen(dup(fd), mode);
     175             :     else
     176         310 :         CFH->private_data = fopen(path, mode);
     177             : 
     178         826 :     if (CFH->private_data == NULL)
     179           0 :         return false;
     180             : 
     181         826 :     return true;
     182             : }
     183             : 
     184             : static bool
     185          36 : open_write_none(const char *path, const char *mode, CompressFileHandle *CFH)
     186             : {
     187             :     Assert(CFH->private_data == NULL);
     188             : 
     189          36 :     CFH->private_data = fopen(path, mode);
     190          36 :     if (CFH->private_data == NULL)
     191           0 :         return false;
     192             : 
     193          36 :     return true;
     194             : }
     195             : 
     196             : /*
     197             :  * Public interface
     198             :  */
     199             : 
     200             : void
     201         862 : InitCompressFileHandleNone(CompressFileHandle *CFH,
     202             :                            const pg_compress_specification compression_spec)
     203             : {
     204         862 :     CFH->open_func = open_none;
     205         862 :     CFH->open_write_func = open_write_none;
     206         862 :     CFH->read_func = read_none;
     207         862 :     CFH->write_func = write_none;
     208         862 :     CFH->gets_func = gets_none;
     209         862 :     CFH->getc_func = getc_none;
     210         862 :     CFH->close_func = close_none;
     211         862 :     CFH->eof_func = eof_none;
     212         862 :     CFH->get_error_func = get_error_none;
     213             : 
     214         862 :     CFH->private_data = NULL;
     215         862 : }