pcpstream.h

/*
    This file is part of Pretty Curved Privacy (pcp1).

    Copyright (C) 2013-2014 T.v.Dein.

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    You can contact me by mail: <tom AT vondein DOT org>.
*/

#ifndef HAVE_PCP_PCPSTEAM_H
#define HAVE_PCP_PCPSTEAM_H

#include <stdarg.h>
#include <stdio.h>
#include <assert.h>
#include "mem.h"
#include "structs.h"
#include "util.h"
#include "defines.h"
#include "context.h"
#include "buffer.h"
#include "z85.h"

/* initialize a new empty stream */
Pcpstream *ps_init(void);

Pcpstream *ps_new_file(FILE *backendfd);

Pcpstream *ps_new_inbuffer(Buffer *b);

Pcpstream *ps_new_outbuffer();


size_t ps_read(Pcpstream *stream, void *buf, size_t readbytes);

size_t ps_write(Pcpstream *stream, void *buf, size_t writebytes);

size_t ps_finish(Pcpstream *stream);

size_t ps_print(Pcpstream *stream, const char * fmt, ...);

size_t ps_tell(Pcpstream *stream);

Buffer *ps_buffer(Pcpstream *stream);

void ps_close(Pcpstream *stream);

int ps_end(Pcpstream *stream);

int ps_err(Pcpstream *stream);


void ps_setdetermine(Pcpstream *stream, size_t blocksize);


void ps_armor(Pcpstream *stream, size_t blocksize);


void ps_unarmor(Pcpstream *stream);



/* read from primary source, decode z85 and out into cache.
   if buf != NULL, consider it as the start of encoded data
   and remove headers and comments, then continue as normal. */
size_t ps_read_decode(Pcpstream *stream);

/* determine if primary source is z85 encoded, put the data
   read from it into the cache */
void ps_determine(Pcpstream *stream);

/* read and decode the next chunk and put it into stream->next */
size_t ps_read_next(Pcpstream *stream);

/* return readbytes from cache. if it is more than left in the cache
   fetch (and decode) the next chunk, append it to cache and return from
   that */
size_t ps_read_cached(Pcpstream *stream, void *buf, size_t readbytes);

/* really read from the source */
size_t ps_read_raw(Pcpstream *stream, void *buf, size_t readbytes);

/* helper, Z85 encodes current cache into the dst buffer */
void ps_write_encode(Pcpstream *stream, Buffer *dst);

/* really write the buffer z into the output stream */
size_t ps_write_buf(Pcpstream *stream, Buffer *z);

/* tell if we really reached eof, caching or not. 1=eof, 0=ok */
int ps_left(Pcpstream *stream);

int ps_readline(Pcpstream *stream, Buffer *line);

#endif // HAVE_PCP_PCPSTEAM_H