buffers.h

This programm is proxy server for ragnarok online game. Also it s can be use as bot. It control all

#ifndef RINGBUF__H
#define RINGBUF__H

/******* Ring Buffer *******/

#include "win_and_sock.h"

typedef struct ringbuf
{
	BYTE * p; // pointer to data
	int len; // length of data
	int sp; // start of data
	int ep; // end of data
    // auxiliary read/write pointers 
    int wp; // write after
    int rp; // read from
} ringbuf; /* [....sp=========ep_.....]   or [====ep_.....sp=======] */

// allocates memory for buffer. returns allocated size.
int alloc_rb(ringbuf * buf,int size);

// release buffer memory
#define free_rb(pbuf) free((pbuf)->p)


// Writes to RB. Return amount of written bytes. Autocommit.
int write_rb(ringbuf * buf, BYTE * src, int srclen);

// Reads from RB. Return amount of read bytes. Autocommit.
int read_rb(ringbuf * buf, BYTE * dest, int sizebuf);


// amount of free space
#define space_rb(buf) ( (buf)->sp - (buf)->wp<=0? \
    (buf)->len + ((buf)->sp - (buf)->wp)-1: \
    ((buf)->sp - (buf)->wp) -1 )

// amount of data ready for reading
#define count_rb(buf) ( (buf)->ep - (buf)->sp>=0? \
    (buf)->ep - (buf)->sp: \
    (buf)->len + ((buf)->ep - (buf)->sp) )


// commit written data
#define wrcom_rb(buf) { (buf)->ep = (buf)->wp;} 

// finish reading
#define rdcom_rb(buf) { (buf)->sp = (buf)->rp;} 

// undo writing
#define wr_undo_rb(buf) { (buf)->wp = (buf)->ep;} 

// undo reading
#define rd_undo_rb(buf) { (buf)->rp = (buf)->sp;} 

// commit or undo writing based on bool predicate. return amount of written data
int wr_done_rb(ringbuf * buf, bool pred);

#define write_rb_B(buf,  b, Res) {BYTE __b = b; Res += write_rb(buf, (BYTE *)&__b, sizeof(BYTE));}
#define write_rb_W(buf,  w, Res) {WORD __w = w; Res += write_rb(buf, (BYTE *)&__w, sizeof(WORD));}
#define write_rb_S(buf,  l, Res) {short __s = s; Res += write_rb(buf, (BYTE *)&__s, sizeof(short));}
#define write_rb_DW(buf, dw, Res) {DWORD __dw = dw; Res += write_rb(buf, (BYTE *)&__dw, sizeof(DWORD));}
#define write_rb_i(buf,  i, Res) {int  __i = i; Res += write_rb(buf, (BYTE *)&__i, sizeof(int));}

WORD read_rb_W(ringbuf * buf);
int read_rb_I(ringbuf * buf);
BYTE read_rb_B(ringbuf * buf);

/********* Stack Buffer *********/

typedef struct stackbuf
{
	BYTE * p; // pointer to data
	int sz; // size of buffer
    int wp; // length of data or pointer to the first free byte
    int rp; // aux pointer for reading
}stackbuf;

// allocates memory for buffer. returns allocated size.
int alloc_sb(stackbuf * buf,int size);

// release buffer memory
#define free_sb(pbuf) free((pbuf)->p)

int write_sb(stackbuf * buf, BYTE * src, int len);

#define write_sb_B(buf,  b, Res) {BYTE __b = b; Res += write_sb(buf, (BYTE *)&__b, sizeof(BYTE));}
#define write_sb_W(buf,  w, Res) {WORD __w = w; Res += write_sb(buf, (BYTE *)&__w, sizeof(WORD));}
#define write_sb_S(buf,  l, Res) {short __s = s; Res += write_sb(buf, (BYTE *)&__s, sizeof(short));}
#define write_sb_DW(buf, dw, Res) {DWORD __dw = dw; Res += write_sb(buf, (BYTE *)&__dw, sizeof(DWORD));}
#define write_sb_i(buf,  i, Res) {int  __i = i; Res += write_sb(buf, (BYTE *)&__i, sizeof(int));}

#define write_sb_POS_at(buf,atp,x,y) {BYTE *__p = (BYTE*)((buf)->p + (buf)->wp + atp); __p[0] = (x)>>2; __p[1] = ((x)<<6) | (((y)>>4)&0x3f); __p[2] = (y)<<4; }
#define write_sb_POS2_at(buf,atp,x0,y0,x1,y1) { BYTE *__p = (BYTE*)((buf)->p + (buf)->wp + atp); __p[0] = (x0)>>2; __p[1] = ((x0)<<6) | (((y0)>>4)&0x3f); __p[2] = ((y0)<<4) | (((x1)>>6)&0x0f); __p[3]=((x1)<<2) | (((y1)>>8)&0x03); __p[4]=(y1); }


#define reset_sb(buf) {(buf)->rp = (buf)->wp = 0;}

int fill_sp(stackbuf * buf, BYTE c, int len);

#define sb_B_AT(buf,atp) (*((BYTE *)((buf)->p + (buf)->wp + atp)))
#define sb_W_AT(buf,atp) (*((WORD *)((buf)->p + (buf)->wp + atp)))
#define sb_S_AT(buf,atp) (*((short *)((buf)->p + (buf)->wp + atp)))
#define sb_DW_AT(buf,atp) (*((DWORD *)((buf)->p + (buf)->wp + atp)))
#define sb_I_AT(buf,atp) (*((int *)((buf)->p + (buf)->wp + atp)))
#define sb_P_AT(buf,atp) ( (buf)->p + (buf)->wp + atp )

#define rsb_B_AT(buf,atp) (*((BYTE *)((buf)->p + (buf)->rp + atp)))
#define rsb_W_AT(buf,atp) (*((WORD *)((buf)->p + (buf)->rp + atp)))
#define rsb_S_AT(buf,atp) (*((short *)((buf)->p + (buf)->rp + atp)))
#define rsb_DW_AT(buf,atp) (*((DWORD *)((buf)->p + (buf)->rp + atp)))
#define rsb_I_AT(buf,atp) (*((int *)((buf)->p + (buf)->rp + atp)))
#define rsb_P_AT(buf,atp) ( (buf)->p + (buf)->rp + atp )

#define read_sb_POS_at(buf,atp,x,y) {BYTE *__p = (BYTE*)((buf)->p + (buf)->rp + atp); x = (__p[0] * 4) + (__p[1] >> 6); y =((__p[1] & 0x3f) << 4) + (__p[2] >> 4); }

int write_sb_at(stackbuf * buf, int atp, BYTE * src, int len);
int fill_sp_at(stackbuf * buf, int atp, BYTE c, int len);

#define commit_sb(buf, len) {(buf)->wp += len;}

#define space_sb(buf) ((buf)->sz - (buf)->wp)
#define count_sb(buf) ((buf)->wp - (buf)->rp)

#endif