Line data    Source code

       1             : #include "burp.h"
       2             : #include "asfd.h"
       3             : #include "async.h"
       4             : #include "bfile.h"
       5             : #include "cmd.h"
       6             : #include "fzp.h"
       7             : #include "iobuf.h"
       8             : #include "log.h"
       9             : 
      10      459908 : int send_msg_fzp(struct fzp *fzp, enum cmd cmd, const char *buf, size_t s)
      11             : {
      12      919816 :         if(fzp_printf(fzp, "%c%04X", cmd, (unsigned int)s)!=5
      13      459908 :           || fzp_write(fzp, buf, s)!=s
      14      919816 :           || fzp_printf(fzp, "\n")!=1)
      15             :         {
      16           0 :                 logp("Unable to write message to file: %s\n", strerror(errno));
      17           0 :                 return -1;
      18             :         }
      19             :         return 0;
      20             : }
      21             : 
      22           0 : static int do_write(struct asfd *asfd, BFILE *bfd,
      23             :         uint8_t *out, size_t outlen, uint64_t *sent)
      24             : {
      25           0 :         int ret=0;
      26           0 :         if((ret=bfd->write(bfd, out, outlen))<=0)
      27             :         {
      28             :                 logp("%s: error when appending %lu: %d\n",
      29           0 :                         __func__, (unsigned long)outlen, ret);
      30           0 :                 asfd->write_str(asfd, CMD_ERROR, "write failed");
      31           0 :                 return -1;
      32             :         }
      33           0 :         *sent+=outlen;
      34           0 :         return 0;
      35             : }
      36             : 
      37           0 : static int do_inflate(struct asfd *asfd, z_stream *zstrm, BFILE *bfd,
      38             :         uint8_t *out, uint64_t *sent)
      39             : {
      40           0 :         int zret=Z_OK;
      41           0 :         unsigned have=0;
      42           0 :         struct iobuf *rbuf=asfd->rbuf;
      43             : 
      44           0 :         zstrm->avail_in=rbuf->len;
      45           0 :         zstrm->next_in=(uint8_t *)rbuf->buf;
      46             : 
      47           0 :         do
      48             :         {
      49           0 :                 zstrm->avail_out=ZCHUNK;
      50           0 :                 zstrm->next_out=out;
      51           0 :                 zret=inflate(zstrm, Z_NO_FLUSH);
      52           0 :                 switch(zret)
      53             :                 {
      54             :                         case Z_NEED_DICT:
      55           0 :                                 zret=Z_DATA_ERROR;
      56             :                         case Z_DATA_ERROR:
      57             :                         case Z_MEM_ERROR:
      58           0 :                                 logp("zstrm inflate error: %d\n", zret);
      59           0 :                                 return -1;
      60             :                 }
      61           0 :                 have=ZCHUNK-zstrm->avail_out;
      62           0 :                 if(!have) continue;
      63             : 
      64           0 :                 if(do_write(asfd, bfd, out, have, sent))
      65             :                         return -1;
      66           0 :         } while(!zstrm->avail_out);
      67             :         return 0;
      68             : }
      69             : 
      70           0 : int transfer_gzfile_in(struct asfd *asfd, const char *path, BFILE *bfd,
      71             :         uint64_t *rcvd, uint64_t *sent, struct cntr *cntr)
      72             : {
      73           0 :         int quit=0;
      74           0 :         int ret=-1;
      75             :         uint8_t out[ZCHUNK];
      76           0 :         struct iobuf *rbuf=asfd->rbuf;
      77             :         z_stream zstrm;
      78             : 
      79           0 :         zstrm.zalloc=Z_NULL;
      80           0 :         zstrm.zfree=Z_NULL;
      81           0 :         zstrm.opaque=Z_NULL;
      82           0 :         zstrm.avail_in=0;
      83           0 :         zstrm.next_in=Z_NULL;
      84             : 
      85           0 :         if(inflateInit2(&zstrm, (15+16)))
      86             :         {
      87           0 :                 logp("unable to init inflate\n");
      88           0 :                 goto end;
      89             :         }
      90             : 
      91             :         while(!quit)
      92             :         {
      93           0 :                 iobuf_free_content(rbuf);
      94           0 :                 if(asfd->read(asfd)) goto end_inflate;
      95           0 :                 (*rcvd)+=rbuf->len;
      96             : 
      97             :                 //logp("transfer in: %c:%s\n", rbuf->cmd, rbuf->buf);
      98           0 :                 switch(rbuf->cmd)
      99             :                 {
     100             :                         case CMD_APPEND: // append
     101           0 :                                 if(!bfd)
     102             :                                 {
     103           0 :                                         logp("given append, but no file to write to\n");
     104             :                                         asfd->write_str(asfd, CMD_ERROR,
     105           0 :                                                 "append with no file");
     106           0 :                                         goto end_inflate;
     107             :                                 }
     108             :                                 else
     109             :                                 {
     110           0 :                                         if(do_inflate(asfd, &zstrm,
     111           0 :                                                 bfd, out, sent))
     112             :                                                         goto end_inflate;
     113             :                                 }
     114             :                                 break;
     115             :                         case CMD_END_FILE: // finish up
     116             :                                 goto end_ok;
     117             :                         case CMD_MESSAGE:
     118             :                         case CMD_WARNING:
     119             :                         {
     120           0 :                                 struct cntr *cntr=NULL;
     121           0 :                                 log_recvd(rbuf, cntr, 0);
     122           0 :                                 break;
     123             :                         }
     124             :                         default:
     125           0 :                                 iobuf_log_unexpected(rbuf, __func__);
     126           0 :                                 goto end_inflate;
     127             :                 }
     128             :         }
     129             : 
     130             : end_ok:
     131             :         ret=0;
     132             : end_inflate:
     133           0 :         inflateEnd(&zstrm);
     134             : end:
     135           0 :         if(ret) logp("transfer file returning: %d\n", ret);
     136           0 :         iobuf_free_content(rbuf);
     137           0 :         return ret;
     138             : }