ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/gvpe/src/util.h
(Generate patch)

Comparing gvpe/src/util.h (file contents):
Revision 1.2 by pcg, Mon Mar 17 15:20:18 2003 UTC vs.
Revision 1.24 by pcg, Tue Dec 4 14:55:59 2007 UTC

1/* 1/*
2 util.h -- process management and other utility functions 2 util.h -- process management and other utility functions
3 Copyright (C) 1998-2002 Ivo Timmermans <ivo@o2w.nl> 3 Copyright (C) 1998-2002 Ivo Timmermans <ivo@o2w.nl>
4 2000-2002 Guus Sliepen <guus@sliepen.eu.org> 4 2000-2002 Guus Sliepen <guus@sliepen.eu.org>
5 2003 Marc Lehmannn <pcg@goof.com> 5 2003 Marc Lehmann <gvpe@schmorp.de>
6 6
7 This file is part of GVPE.
8
7 This program is free software; you can redistribute it and/or modify 9 GVPE is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by 10 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or 11 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version. 12 (at your option) any later version.
11 13
12 This program is distributed in the hope that it will be useful, 14 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details. 17 GNU General Public License for more details.
16 18
17 You should have received a copy of the GNU General Public License 19 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software 20 along with gvpe; if not, write to the Free Software
19 Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20*/ 22*/
21 23
22#ifndef UTIL_H__ 24#ifndef UTIL_H__
23#define UTIL_H__ 25#define UTIL_H__
24 26
25#include <sys/socket.h> 27#include <cstring>
26#include <netinet/in.h>
27 28
28#include <map> 29#include <openssl/rsa.h>
29 30
30#include "device.h" 31#include "gettext.h"
31 32
32#define SOCKADDR sockaddr_in // this is lame, I know 33#include "slog.h"
34#include "ev_cpp.h"
35#include "callback.h"
36
37typedef ev_tstamp tstamp;
33 38
34/* 39/*
35 * check for an existing vped for this net, and write pid to pidfile 40 * check for an existing gvpe for this net, and write pid to pidfile
36 */ 41 */
37extern int write_pidfile (void); 42extern int write_pidfile (void);
38 43
39/* 44/*
40 * kill older vped 45 * kill older gvpe
41 */ 46 */
42extern int kill_other (int signal); 47extern int kill_other (int signal);
43 48
44/* 49/*
45 * Detach from current terminal, write pidfile, kill parent 50 * Detach from current terminal, write pidfile, kill parent
46 */ 51 */
47extern int detach (int do_detach); 52extern int detach (int do_detach);
48 53
49/* 54/*
50 * Set all files and paths according to netname
51 */
52extern void make_names (void);
53
54/*
55 * check wether the given path is an absolute pathname 55 * check wether the given path is an absolute pathname
56 */ 56 */
57#define ABSOLUTE_PATH(c) ((c)[0] == '/') 57#define ABSOLUTE_PATH(c) ((c)[0] == '/')
58 58
59static inline void 59/*****************************************************************************/
60
61typedef u8 mac[6];
62
60id2mac (unsigned int id, void *m) 63extern void id2mac (unsigned int id, void *m);
64
65#define mac2id(p) ((p)[0] & 0x01 ? 0 : ((p)[4] << 8) | (p)[5])
66
67struct sliding_window
61{ 68{
62 mac &p = *(mac *)m;
63
64 p[0] = 0xfe;
65 p[1] = 0xfd;
66 p[2] = 0x80;
67 p[3] = 0x00;
68 p[4] = id >> 8;
69 p[5] = id;
70}
71
72#define mac2id(p) (p[0] & 0x01 ? 0 : (p[4] << 8) | p[5])
73
74// a very simple fifo pkt-queue
75class pkt_queue
76 {
77 tap_packet *queue[QUEUEDEPTH];
78 int i, j;
79
80 public:
81
82 void put (tap_packet *p);
83 tap_packet *get ();
84
85 pkt_queue ();
86 ~pkt_queue ();
87 };
88
89struct sockinfo
90 {
91 u32 host;
92 u16 port;
93
94 void set (const SOCKADDR *sa)
95 {
96 host = sa->sin_addr.s_addr;
97 port = sa->sin_port;
98 }
99
100 sockinfo()
101 {
102 host = port = 0;
103 }
104
105 sockinfo(const SOCKADDR &sa)
106 {
107 set (&sa);
108 }
109
110 sockinfo(const SOCKADDR *sa)
111 {
112 set (sa);
113 }
114
115 SOCKADDR *sa()
116 {
117 static SOCKADDR sa;
118
119 sa.sin_family = AF_INET;
120 sa.sin_port = port;
121 sa.sin_addr.s_addr = host;
122
123 return &sa;
124 }
125
126 operator const char *();
127 };
128
129inline bool
130operator == (const sockinfo &a, const sockinfo &b)
131{
132 return a.host == b.host && a.port == b.port;
133}
134
135inline bool
136operator < (const sockinfo &a, const sockinfo &b)
137{
138 return a.host < b.host
139 || (a.host == b.host && a.port < b.port);
140}
141
142// only do action once every x seconds per host.
143// currently this is quite a slow implementation,
144// but suffices for normal operation.
145struct u32_rate_limiter : private map<u32, time_t>
146 {
147 int every;
148
149 bool can (u32 host);
150
151 u32_rate_limiter (time_t every = 1)
152 {
153 this->every = every;
154 }
155 };
156
157struct net_rate_limiter : u32_rate_limiter
158 {
159 bool can (SOCKADDR *sa) { return u32_rate_limiter::can((u32)sa->sin_addr.s_addr); }
160 bool can (sockinfo &si) { return u32_rate_limiter::can((u32)si.host); }
161
162 net_rate_limiter (time_t every) : u32_rate_limiter (every) {}
163 };
164
165struct sliding_window {
166 u32 v[(WINDOWSIZE + 31) / 32]; 69 u32 v[(WINDOWSIZE + 31) / 32];
167 u32 seq; 70 u32 seq;
168 71
169 void reset (u32 seqno) 72 void reset (u32 seqno)
170 { 73 {
… …
174 77
175 bool recv_ok (u32 seqno) 78 bool recv_ok (u32 seqno)
176 { 79 {
177 if (seqno <= seq - WINDOWSIZE) 80 if (seqno <= seq - WINDOWSIZE)
178 slog (L_ERR, _("received duplicate or outdated packet (received %08lx, expected %08lx)\n" 81 slog (L_ERR, _("received duplicate or outdated packet (received %08lx, expected %08lx)\n"
179 "possible replay attack, or just massive packet reordering"), seqno, seq + 1);//D 82 "possible replay attack, or just massive packet reordering"), seqno, seq + 1);
180 else if (seqno > seq + WINDOWSIZE) 83 else if (seqno > seq + WINDOWSIZE * 4)
181 slog (L_ERR, _("received duplicate or out-of-sync packet (received %08lx, expected %08lx)\n" 84 slog (L_ERR, _("received duplicate or out-of-sync packet (received %08lx, expected %08lx)\n"
182 "possible replay attack, or just massive packet loss"), seqno, seq + 1);//D 85 "possible replay attack, or just massive packet loss"), seqno, seq + 1);
183 else 86 else
184 { 87 {
185 while (seqno > seq) 88 while (seqno > seq)
186 { 89 {
187 seq++; 90 seq++;
… …
195 98
196 u32 s = seqno % WINDOWSIZE; 99 u32 s = seqno % WINDOWSIZE;
197 u32 *cell = v + (s >> 5); 100 u32 *cell = v + (s >> 5);
198 u32 mask = 1 << (s & 31); 101 u32 mask = 1 << (s & 31);
199 102
200 //printf ("received seqno %08lx, seq %08lx, mask %08lx is %08lx\n", seqno, seq, mask, ismask);
201 if (*cell & mask) 103 if (*cell & mask)
202 {
203 slog (L_ERR, _("received duplicate packet (received %08lx, expected %08lx)\n" 104 slog (L_ERR, _("received duplicate packet (received %08lx, expected %08lx)\n"
204 "possible replay attack, or just packet duplication"), seqno, seq + 1);//D 105 "possible replay attack, or just packet duplication"), seqno, seq + 1);
205 return false;
206 }
207 else 106 else
208 { 107 {
209 *cell |= mask; 108 *cell |= mask;
210 return true; 109 return true;
211 } 110 }
212 } 111 }
112
113 return false;
213 } 114 }
214}; 115};
215 116
117typedef callback<const char * ()> run_script_cb;
118
119// run a shell script (or actually an external program).
120bool run_script (const run_script_cb &cb, bool wait);
121
122#if ENABLE_HTTP_PROXY
123u8 *base64_encode (const u8 *data, unsigned int len);
216#endif 124#endif
217 125
126/*****************************************************************************/
127
128typedef u8 rsaclear[RSA_KEYLEN - RSA_OVERHEAD]; // challenge data;
129typedef u8 rsacrypt[RSA_KEYLEN]; // encrypted challenge
130
131static inline void
132rsa_encrypt (RSA *key, const rsaclear &chg, rsacrypt &encr)
133{
134 if (RSA_public_encrypt (sizeof chg,
135 (unsigned char *)&chg, (unsigned char *)&encr,
136 key, RSA_PKCS1_OAEP_PADDING) < 0)
137 fatal ("RSA_public_encrypt error");
138}
139
140static inline bool
141rsa_decrypt (RSA *key, const rsacrypt &encr, rsaclear &chg)
142{
143 return RSA_private_decrypt (sizeof encr,
144 (unsigned char *)&encr, (unsigned char *)&chg,
145 key, RSA_PKCS1_OAEP_PADDING) > 0;
146}
147
148#endif
149

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines