common.h

sock protocol ,it is useful!

														*/
			in_port_t		srcport;				/* 75-76: connect request; port used
														 *			 on client behalf.
														*/
			in_port_t		boundport;			/* 77-78: bind request; port used
														 *		 on client behalf.
														*/
			in_addr_t		boundaddr;			/* 79-82: addr used on client behalf*/
			char				pad30[90];			/* 83-172									*/
		} _6;

	} packet;
};

struct msproxy_response_t {
	int32_t					packetid;			/* 1-4										*/
	int32_t					magic5;				/* 5-8										*/
	int32_t              serverid;			/* 9-12										*/
	char						clientack;			/* 13: ack of last client packet.	*/
	char						pad5[3];				/* 14-16										*/
	unsigned char			sequence;			/* 17: sequence # of this packet.	*/
	char						pad10[7];			/* 18-24										*/
	char						RWSP[4];				/* 25-28: 0x52,0x57,0x53,0x50			*/
	char						pad15[8];			/* 29-36										*/
	int16_t					command;				/* 37-38										*/

	union {
		struct {
			char				pad5[18];			/* 39-56										*/
			int16_t			magic20;				/* 57-58: 0x02, 0x00						*/
			char				pad10[6];			/* 59-64										*/
			int16_t			magic30;				/* 65-66: 0x74, 0x01						*/
			char				pad15[2];			/* 67-68										*/
			int16_t			magic35;				/* 69-70: 0x0c, 0x00						*/
			char				pad20[6];			/* 71-76										*/
			int16_t			magic50;				/* 77-78: 0x04, 0x00						*/
			char				pad30[6];			/* 79-84										*/
			int16_t			magic60;				/* 85-86: 0x65, 0x05						*/
			char				pad35[2];			/* 87-88										*/
			int16_t			magic65;				/* 89-90: 0x02, 0x00						*/
			char				pad40[8];			/* 91-98										*/
			in_port_t		udpport;				/* 99-100									*/
			in_addr_t		udpaddr;				/* 101-104									*/
		} _1;

		struct {
			char				pad5[18];			/* 39-56										*/
			int16_t			magic5;				/* 57-58: 0x01, 0x00						*/
		} _2;

		struct {
			char				pad1[6];				/* 39-44										*/
			int32_t			magic10;				/* 45-48										*/
			char				pad3[10];			/* 49-58										*/
			in_port_t		boundport;			/* 59-60: port server bound for us.	*/
			in_addr_t		boundaddr;			/* 61-64: addr server bound for us.	*/
			char				pad10[4];			/* 65-68										*/
			int16_t			magic15;				/* 69-70										*/
			char				pad15[102];			/* 70-172									*/
			char				NTLMSSP[sizeof("NTLMSSP")];	/* 173-180: "NTLMSSP"	*/
			int16_t			magic50;				/* 181-182: 0x02, 0x00					*/
			char				pad50[2];			/* 183-184									*/
			int16_t			magic55;				/* 185-186: 0x08, 0x00					*/
			int16_t			magic60;				/* 187-188: 0x08, 0x00					*/
			int16_t			magic65;				/* 189-190: 0x28, 0x00					*/
			char				pad60[2];			/* 191-192									*/
			int16_t			magic70;				/* 193-194: 0x96, 0x82					*/
			int16_t			magic75;				/* 195-196: 0x01, 0x00					*/
			char				pad70[16];			/* 197-212									*/
			char				ntdomain[257];		/* 213-EOP									*/
		} _3;

		struct {
			char				pad5[134];			/* 39-172									*/
		} _4;

		struct {
			unsigned char	addroffset;			/* 39: weird, probably wrong.			*/
			char				pad5[13];			/* 40-52										*/
			in_addr_t		hostaddr;			/* ?-?+4										*/
		} resolve;

		struct {
			int16_t			magic1;				/* 39-40										*/
			char				pad5[18];			/* 41-58										*/
			in_port_t		clientport;			/* 59-60: forwarded port.				*/
			in_addr_t		clientaddr;			/* 61-64: forwarded address.			*/
			int32_t			magic10;				/* 65-68										*/
			int32_t			magic15;				/* 69-72										*/
			in_port_t		serverport;			/* 73-74: port server will connect
														 *	       to us from.
														*/
			in_port_t		srcport;				/* 75-76: connect request; port used
														 *			 on client behalf.
														*/
			in_port_t		boundport;			/* 77-78: bind request; port used
														 *			 on client behalf.
														*/
			in_addr_t		boundaddr;			/* 79-82: addr used on client behalf*/
			char				pad10[90];			/* 83-172									*/
		} _5;
	} packet;
};

struct request_t {
	unsigned char			version;
	unsigned char			command;
	unsigned char			flag;
	struct sockshost_t	host;
	struct authmethod_t	*auth;	/* pointer to level above. */
};


struct response_t {
	unsigned char			version;
	unsigned char			reply;
	unsigned char			flag;
	struct sockshost_t	host;
	struct authmethod_t	*auth;	/* pointer to level above. */
};

/* encapsulation for udp packets. */
struct udpheader_t {
	unsigned char			flag[2];
	unsigned char			frag;
	struct sockshost_t	host;
};


/* interface request packet. */
struct interfacerequest_t {
	unsigned char			rsv;
	unsigned char			sub;
	unsigned char			flag;
	struct sockshost_t	host;
};


/* method username */
struct uname_t {
	unsigned char	version;
	char				name[MAXNAMELEN];
	char				password[MAXPWLEN];
};

/* method rfc931 */
struct rfc931_t {
	char				name[MAXNAMELEN];
};

/* this must be big enough to hold a complete method request. */
struct authmethod_t {
	int						matched;	/* authentication matched?	*/
	int						method;	/* method in use.				*/
	union {
		struct uname_t		uname;
		struct rfc931_t	rfc931;
	} mdata;
};


struct method_t {
	unsigned none:1;
	unsigned uname:1;
	unsigned :0;
};


struct protocol_t {
	unsigned tcp:1;
	unsigned udp:1;
	unsigned :0;
};


struct command_t {
	unsigned bind:1;
	unsigned connect:1;
	unsigned udpassociate:1;

	/* not real commands as per standard, but they have their use. */
	unsigned bindreply:1;		/* reply to bind command.	*/
	unsigned udpreply:1;			/* reply to udp packet.		*/
	unsigned :0;
};


struct proxyprotocol_t {
	unsigned socks_v4:1;
	unsigned socks_v5:1;
	unsigned msproxy_v2:1;
	unsigned :0;
};


struct serverstate_t {
	struct command_t			command;
	struct extension_t		extension;
	struct protocol_t			protocol;
	int							methodv[AUTHMETHOD_MAX];/* methods to offer.			*/
	int							methodc;						/* number of methods set.	*/
	struct proxyprotocol_t	proxyprotocol;
};


struct msproxy_state_t {
	struct sockaddr_in		controladdr;	/* udp address of proxyserver.		*/
	int32_t						magic25;
	int32_t						bindid;
	int32_t						clientid;
	int32_t						serverid;
	unsigned char				seq_recv;		/* seq number of last packet recv.	*/
	unsigned char				seq_sent;		/* seq number of last packet sent.	*/
};


struct gateway_t {
	struct sockshost_t			host;
	struct serverstate_t			state;
};

/* values in parentheses designate "don't care" values.	*/
struct socksstate_t {
	int							acceptpending;	/* a accept pending?		(-1)			*/
	struct authmethod_t		auth;				/* authentication in use.				*/
	int							command;			/* command (-1)							*/
	int							err;				/* if request failed, errno.			*/
	int							inprogress;		/* operation in progress? (-1)		*/
#ifdef SOCKS_TRYHARDER
	int							lock;				/* some calls require a lock.			*/
#endif
	struct msproxy_state_t	msproxy;			/* if msproxy, msproxy state.			*/
	struct protocol_t			protocol;		/* protocol in use.						*/
	unsigned						udpconnect:1;	/* connected udp socket?				*/
	int							system;			/* don't check, use system call.		*/
	int							version;			/* version									*/
};


struct ruleaddress_t {
	char						atype;
	union {

		char					domain[MAXHOSTNAMELEN];

		struct {
			struct in_addr	ip;
			struct in_addr	mask;
		} ipv4;

	} addr;

	struct {
		in_port_t			tcp;			/* tcp portstart or field to operator on.	*/
		in_port_t			udp;			/* udp portstart or field to operator on.	*/
	} port;
	in_port_t				portend;		/* only used if operator is range.			*/
	enum operator_t		operator;	/* operator to compare ports via.			*/
};

struct route_t {
	int							number;		/* routenumber.								*/

	struct {
		unsigned bad:1;		/* route is bad?								*/
		unsigned direct:1;	/* direct connection, no proxy.			*/
		unsigned :0;
	} state;


	struct ruleaddress_t		src;
	struct ruleaddress_t		dst;
	struct gateway_t			gw;

	struct route_t				*next;		/* next route in list.						*/
};


struct socks_t {
	unsigned char				version;
									/*
									 *	Negotiated version.  Each request and
									 *	response will also contain a version number, that
									 *	is the version number given for that particular
									 *	packet and should be checked to make sure it is
									 *  the same as the negotiated version.
									*/
	struct request_t				req;
	struct response_t				res;
	struct authmethod_t			auth;
	struct gateway_t				gw;
	struct socksstate_t			state;
};



enum portcmp { e_lt, e_gt, e_eq, e_neq, e_le, e_ge, e_nil };
typedef enum portcmp Portcmp;



/*
 * for use in generic functions that take either reply or request
 * packets, include a field indicating what it is.
 */
#define SOCKS_REQUEST	0x1
#define SOCKS_RESPONSE	0x2

struct socksfd_t {
	unsigned					allocated:1;/* allocated?										*/
	int						control;		/* control connection to server.				*/
	struct socksstate_t	state;		/* state of this connection.					*/
	unsigned					:0;
	struct sockaddr		local;		/* local address of data connection.		*/
	unsigned					:0;
	struct sockaddr		server;		/* remote address of data connection.		*/
	unsigned					:0;
	struct sockaddr		remote;		/* address server is using on our behalf.	*/
	unsigned					:0;
	struct sockaddr		reply;		/* address to expect reply from.				*/

	/* XXX union this. */
	unsigned					:0;
	struct sockaddr		accepted;	/* address server accepted for us.			*/
	unsigned					:0;
	struct sockaddr		connected;	/* address server connected to for us.		*/

	struct route_t		*route;
};

__BEGIN_DECLS

/*
 * versions of BSD's error functions that log via slog() instead.
 */

#ifdef STDC_HEADERS
void serr(int eval, const char *fmt, ...);
#else
void serr();
#endif  /* STDC_HEADERS */

#ifdef STDC_HEADERS
void serrx(int eval, const char *fmt, ...);
#else
void serrx();
#endif  /* STDC_HEADERS */

#ifdef STDC_HEADERS
void swarn(const char *fmt, ...);
#else
void swarn();
#endif  /* STDC_HEADERS */

#ifdef STDC_HEADERS
void swarnx(const char *fmt, ...);
#else
void swarnx();
#endif  /* STDC_HEADERS */

void
genericinit __P((void));
/*
 * Generic init, called after clientinit()/serverinit().
 */

void
initlog __P((void));
/*
 * (Re)initialize logging.
 */


struct udpheader_t *
sockaddr2udpheader __P((const struct sockaddr *to, struct udpheader_t *header));
/*
 * Writes a udpheader representation of "to" to "header".
 * Returns a pointer to "header".
 */

char *
udpheader_add __P((const struct sockshost_t *host, char *msg, size_t *len,
						 size_t msgsize));
/*
 * Prefixes the udpheader_t version of "host" to a copy of "msg",
 * which is of length "len".
 * "msgsize" gives the size of the memory pointed to by "msg".
 * If "msgsize" is large enough the function will prepend the udpheader
 * to "msg" directly (moving the old contents to the right) rather than
 * allocating new memory.
 * Upon return "len" gives the length of the new "msg".
 *
 *	Returns:
 *		On success: "msg" with the udpheader prepended.
 *		On failure: NULL (out of memory).
 */

struct udpheader_t *
string2udpheader __P((const char *data, size_t len,
							 struct udpheader_t *header));
/*
 * Converts "data" to udpheader_t representation.
 * "len" is length of "data".
 * "data" is assumed to be in network order.
 * Returns:
 *		On success: pointer to a udpheader_t in static memory.
 *		On failure: NULL ("data" is not a complete udppacket).
 */


const char *
socks_packet2string __P((const void *packet, int type));
/*
 * debug function; dumps socks packet content
 * "packet" is a socks packet, "type" indicates it's type.
 * Returns:
 *		On success: 0
 *		On failure: -1
 */

int
socks_socketisbound __P((int s));
/*
 * Returns:
 *		If "s" is bound: 1
 *		If "s" is not bound: 0
 *		If "s" is not socket or error occurred determining if bound: -1
 */

int
fdisopen __P((int fd));
/*
 * returns 1 if the filedescriptor "fd" currently references a open object.
 * returns 0 otherwise.
 */

void
closev __P((int *array, int count));
/*
 * Goes through "array", which contains "count" elements.
 * Each element that does not have a negative value is closed.
 */

int
socks_logmatch __P((unsigned int d, const struct logtype_t *log));
/*
 * Returns true if "d" is a descriptor matching any descriptor in "log".
 * Returns false otherwise.
 */

char *
sockaddr2string __P((const struct sockaddr *address, char *string, size_t len));
/*
 * Returns the ip address and port in "address" on string form.
 * "address" is assumed to be on network form and it will be
 * converted to host form before written to "string".
 * "len" gives length of the NUL terminated string.
 * Returns: "string".
 */


struct sockaddr *
sockshost2sockaddr __P((const struct sockshost_t *shost,
								struct sockaddr *addr));
/*
 * Converts the sockhost_t "shost" to a sockaddr struct and stores it
 * in "addr".
 * Returns: "addr".
 */

struct sockaddr *
fakesockshost2sockaddr __P((const struct sockshost_t *host,
									 struct sockaddr *addr));
/*
 * Like sockshost2sockaddr(), but checks whether the address in
 * "host" is fake when converting.
 */

struct sockshost_t *
sockaddr2sockshost __P((const struct sockaddr *addr, struct sockshost_t *host));
/*
 * Converts the sockaddr struct "shost" to a sockshost_t struct and stores it
 * in "host".
 * Returns: "host".
 */

struct sockshost_t *
ruleaddress2sockshost __P((const struct ruleaddress_t *address,
									struct sockshost_t *host, int protocol));
/*
 * Converts the ruleaddress_t "address" to a sockshost_t struct and stores it
 * in "host".
 * Returns: "host".
 */

struct ruleaddress_t *
sockshost2ruleaddress __P((const struct sockshost_t *host,
									struct ruleaddress_t *addr));
/*
 * Converts the sockshost_t "host" to a ruleaddress_t struct and stores it
 * in "addr".
 * Returns: "addr".
 */

struct ruleaddress_t *
sockaddr2ruleaddress __P((const struct sockaddr *addr,
							struct ruleaddress_t *ruleaddr));
/*
 * Converts the struct sockaddr "addr" to a ruleaddress_t struct and stores it
 * in "ruleaddr".
 * Returns: "addr".
 */

int
sockatmark __P((int s));
/*