1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
/* $Id: pxy.h,v 1.8 2004/05/27 14:18:43 mjt Exp $
* open proxy checker, common definitions.
* Michael Tokarev <mjt@corpit.ru>.
* This code may be freely used and distributed according to
* the terms of General Public License (GPL) version 2 or later.
*/
#ifndef _PXY_H
#define _PXY_H
#include "event.h"
#if !defined(__GNUC__) && !defined(__attribute__)
# define __attribute__(c)
#endif
#ifndef UNUSED
# define UNUSED __attribute__((unused))
#endif
#ifndef PRINTFLIKE
# define PRINTFLIKE(f,v) __attribute__((format(printf,f,v)))
#endif
typedef struct pxyconn pxyconn_t;
typedef unsigned short ipport_t;
typedef struct {
unsigned len; /* current length in buffer */
char buf[128-3*sizeof(unsigned)]; /* the buffer itself */
} pxybuf_t;
extern char pxybuf[8193];
/* Proxy protocol definition. */
typedef struct {
const char *name; /* "canonical" name of a protocol */
const char *aname; /* alternative name */
const char *transport;/* http */
const char *fullname; /* HTTP CONNECT */
int family; /* internal code: "family" of proto, HTTP, FTP, etc */
void (*handler)(pxyconn_t *, int); /* protocol handler */
int (*check)(pxyconn_t *c, char *buf, int l);
} pxyproto_t;
extern const pxyproto_t pxyprotos[]; /* array of all supported protocols */
typedef struct {
const pxyproto_t *proto;
const ipport_t *ports;
int advanced;
} pxyprobe_t;
extern const pxyprobe_t pxyprobes[];
/* Active proxy connection structure.
* There aren't many of those: upper limit is the
* number of open files.
* The structure supposed to be "embedded" into another
* structure with additional data for higher-level protocol
* handled by hlcbck routine.
*/
struct pxyconn {
int fd; /* filedescriptor */
struct in_addr pxyaddr; /* address of a proxy */
struct in_addr dstaddr; /* address of destination */
ipport_t pxyport; /* port number of a proxy */
ipport_t dstport; /* port number of destination */
const pxyproto_t *proto; /* proxy protocol description */
pxybuf_t *buf; /* buffer holding data read from net */
int pxystate; /* current proxy protocol state */
int appstate; /* current application protocol state */
int nread; /* number of bytes read so far */
void *data; /* app-supplied data */
char *detail; /* strdup'ed additional info if any */
struct ev_tm timer; /* I/O timer */
pxyconn_t *next; /* for linked lists, app usage */
};
extern int pxytimeout;
/* almost all routines returns > 0 on ok and 0 on error;
* in error case, pxyaction will be called automatically. */
/* allocate new connection structure */
pxyconn_t *pxynew();
/* free connection resources, timers etc */
void pxyfree(pxyconn_t *c);
/* start new connection attempt */
int pxystart(pxyconn_t *c, int fd);
/* renew a timer; if tmo==0, use pxytimeout */
int pxyrenew(pxyconn_t *c, int tmo, void (*tmfn)(pxyconn_t*));
int pxyreqio(pxyconn_t *c, int e, void(*fn)(pxyconn_t*,int));
int
pxyreqiot(pxyconn_t *c, int e, void(*iofn)(pxyconn_t*,int),
int tmo, void(*tmfn)(pxyconn_t*));
/* read bytes from connection, return number of bytes read (>=0)
or call pxyaction and return -1. In case of EAGAIN, returns 0
if minlen == 0, or -1 as error */
int pxyread(pxyconn_t *c, char *buf, int l, int minlen, int loglevel);
/* read next chunk of bytes into pxybuf[] together with saved data,
return number of bytes available (>0) or call pxyaction and
return 0 */
int pxyreadnext(pxyconn_t *c, int minlen, int *tlen, int loglevel);
/* save data from buf of len `len', at most max bytes, within
connection structure. Calls pxyaction on error */
int pxysave(pxyconn_t *c, char *buf, unsigned len, unsigned max);
/* write something from buf of length len to the remote, with logging */
int pxywrite(pxyconn_t *c, const char *buf, int len, int loglevel);
int pxyprintf(pxyconn_t *c, int loglevel, const char *fmt, ...)
PRINTFLIKE(3,4);
/* app-supplied: */
void pxyinfo(const pxyconn_t *c, int level, const char *fmt, ...)
PRINTFLIKE(3,4);
void pxyaction(pxyconn_t *c, int result);
/* 0 - connected, 1 - done, 2 - definitely not open, -1 - err.
* Should free connection in case result != 0, or change event
* callback if == 0. */
int pxygetdata(pxyconn_t *c);
/* fills in pxybuf[] with app-data for one-shot proxies and
* returns length of it */
void pxycheckdata(pxyconn_t *c);
/* all-in-once result check */
/* log the raw io: direction is 0 for read and 1 for write */
void pxyvio(pxyconn_t *c, int loglevel, int direction,
const char *buf, int bufl);
#endif
|
