gvpe/src/util.h

/*
    util.h -- process management and other utility functions
    Copyright (C) 1998-2002 Ivo Timmermans <ivo@o2w.nl>
                  2000-2002 Guus Sliepen <guus@sliepen.eu.org>
                  2003-2011 Marc Lehmann <gvpe@schmorp.de>
 
    This file is part of GVPE.

    GVPE 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/>.
   
    Additional permission under GNU GPL version 3 section 7
   
    If you modify this Program, or any covered work, by linking or
    combining it with the OpenSSL project's OpenSSL library (or a modified
    version of that library), containing parts covered by the terms of the
    OpenSSL or SSLeay licenses, the licensors of this Program grant you
    additional permission to convey the resulting work.  Corresponding
    Source for a non-source form of such a combination shall include the
    source code for the parts of OpenSSL used as well as that of the
    covered work.
*/

#ifndef UTIL_H__
#define UTIL_H__

#include <cstring>
#include <sys/types.h>

#include <openssl/rsa.h>

#include "gettext.h"

#include "slog.h"
#include "ev_cpp.h"
#include "callback.h"

typedef ev_tstamp tstamp;

/*
 * check for an existing gvpe for this net, and write pid to pidfile
 */
extern int write_pidfile (void);

/*
 * kill older gvpe
 */
extern int kill_other (int signal);

/*
 * Detach from current terminal, write pidfile, kill parent
 */
extern int detach (int do_detach);

/*
 * check wether the given path is an absolute pathname
 */
#define ABSOLUTE_PATH(c) ((c)[0] == '/')

/*****************************************************************************/

typedef u8 mac[6];

extern void id2mac (unsigned int id, void *m);

#define mac2id(p) ((p)[0] & 0x01 ? 0 : ((p)[4] << 8) | (p)[5])

struct sliding_window
{
  u32 v[(WINDOWSIZE + 31) / 32];
  u32 seq;

  void reset (u32 seqno)
    {
      memset (v, -1, sizeof v);
      seq = seqno;
    }

  // 0 == ok, 1 == far history, 2 == duplicate in-window, 3 == far future
  int seqno_classify (u32 seqno)
    {
      if (seqno <= seq - WINDOWSIZE)
        return 1;
      else if (seqno > seq + WINDOWSIZE * 16)
        return 3;
      else
        {
          while (seqno > seq)
            {
              seq++;

              u32 s = seq % WINDOWSIZE;
              u32 *cell = v + (s >> 5);
              u32 mask = 1 << (s & 31);

              *cell &= ~mask;
            }

          u32 s = seqno % WINDOWSIZE;
          u32 *cell = v + (s >> 5);
          u32 mask = 1 << (s & 31);

          if (*cell & mask)
            return 2;
          else
            {
              *cell |= mask;
              return 0;
            }
        }
    }
};

typedef callback<const char *()> run_script_cb;

// run a shell script (or actually an external program).
pid_t run_script (const run_script_cb &cb, bool wait);

#if ENABLE_HTTP_PROXY
u8 *base64_encode (const u8 *data, unsigned int len);
#endif

/*****************************************************************************/

typedef u8 rsaclear[RSA_KEYLEN - RSA_OVERHEAD]; // challenge data;
typedef u8 rsacrypt[RSA_KEYLEN]; // encrypted challenge

static inline void
rsa_encrypt (RSA *key, const rsaclear &chg, rsacrypt &encr)
{
  if (RSA_public_encrypt (sizeof chg,
                          (unsigned char *)&chg, (unsigned char *)&encr,
                          key, RSA_PKCS1_OAEP_PADDING) < 0)
    fatal ("RSA_public_encrypt error");
}

static inline bool
rsa_decrypt (RSA *key, const rsacrypt &encr, rsaclear &chg)
{
  return RSA_private_decrypt (sizeof encr,
                              (unsigned char *)&encr, (unsigned char *)&chg,
                              key, RSA_PKCS1_OAEP_PADDING) > 0;
}

/*****************************************************************************/

// run work_cb in another thread, call done_cb in main thread when finished
// only one work_cb will execute at any one time.
void async (callback<void ()> work_cb, callback<void ()> done_cb);

#endif

Revision:	1.30
Committed:	Tue Mar 8 17:34:26 2011 UTC (15 years, 6 months ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rel-2_25
Changes since 1.29:	+2 -0 lines
Log Message:	async functionality, unused
#	User	Rev	Content
1	pcg	1.1	/*
2			util.h -- process management and other utility functions
3			Copyright (C) 1998-2002 Ivo Timmermans <ivo@o2w.nl>
4			2000-2002 Guus Sliepen <guus@sliepen.eu.org>
5	root	1.29	2003-2011 Marc Lehmann <gvpe@schmorp.de>
6	pcg	1.1
7	pcg	1.13	This file is part of GVPE.
8
9	pcg	1.25	GVPE is free software; you can redistribute it and/or modify it
10			under the terms of the GNU General Public License as published by the
11			Free Software Foundation; either version 3 of the License, or (at your
12			option) any later version.
13
14			This program is distributed in the hope that it will be useful, but
15			WITHOUT ANY WARRANTY; without even the implied warranty of
16			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
17			Public License for more details.
18
19			You should have received a copy of the GNU General Public License along
20			with this program; if not, see <http://www.gnu.org/licenses/>.
21
22			Additional permission under GNU GPL version 3 section 7
23
24			If you modify this Program, or any covered work, by linking or
25			combining it with the OpenSSL project's OpenSSL library (or a modified
26			version of that library), containing parts covered by the terms of the
27			OpenSSL or SSLeay licenses, the licensors of this Program grant you
28			additional permission to convey the resulting work. Corresponding
29			Source for a non-source form of such a combination shall include the
30			source code for the parts of OpenSSL used as well as that of the
31			covered work.
32	pcg	1.1	*/
33
34			#ifndef UTIL_H__
35			#define UTIL_H__
36
37	pcg	1.24	#include <cstring>
38	pcg	1.26	#include <sys/types.h>
39	pcg	1.24
40	pcg	1.11	#include <openssl/rsa.h>
41
42	pcg	1.15	#include "gettext.h"
43
44	pcg	1.10	#include "slog.h"
45	pcg	1.20	#include "ev_cpp.h"
46			#include "callback.h"
47
48	pcg	1.21	typedef ev_tstamp tstamp;
49	pcg	1.1
50			/*
51	pcg	1.16	* check for an existing gvpe for this net, and write pid to pidfile
52	pcg	1.1	*/
53			extern int write_pidfile (void);
54
55			/*
56	pcg	1.16	* kill older gvpe
57	pcg	1.1	*/
58			extern int kill_other (int signal);
59
60			/*
61			* Detach from current terminal, write pidfile, kill parent
62			*/
63			extern int detach (int do_detach);
64
65			/*
66			* check wether the given path is an absolute pathname
67			*/
68			#define ABSOLUTE_PATH(c) ((c)[0] == '/')
69	pcg	1.10
70	pcg	1.11	/*****************************************************************************/
71
72	pcg	1.10	typedef u8 mac[6];
73	pcg	1.1
74	pcg	1.8	extern void id2mac (unsigned int id, void *m);
75	pcg	1.1
76	pcg	1.8	#define mac2id(p) ((p)[0] & 0x01 ? 0 : ((p)[4] << 8) \| (p)[5])
77	pcg	1.1
78	pcg	1.22	struct sliding_window
79			{
80	pcg	1.2	u32 v[(WINDOWSIZE + 31) / 32];
81			u32 seq;
82
83			void reset (u32 seqno)
84			{
85			memset (v, -1, sizeof v);
86			seq = seqno;
87			}
88
89	pcg	1.28	// 0 == ok, 1 == far history, 2 == duplicate in-window, 3 == far future
90	pcg	1.27	int seqno_classify (u32 seqno)
91	pcg	1.2	{
92			if (seqno <= seq - WINDOWSIZE)
93	pcg	1.27	return 1;
94			else if (seqno > seq + WINDOWSIZE * 16)
95	pcg	1.28	return 3;
96	pcg	1.2	else
97			{
98			while (seqno > seq)
99			{
100			seq++;
101
102			u32 s = seq % WINDOWSIZE;
103			u32 *cell = v + (s >> 5);
104			u32 mask = 1 << (s & 31);
105
106			*cell &= ~mask;
107			}
108
109			u32 s = seqno % WINDOWSIZE;
110			u32 *cell = v + (s >> 5);
111			u32 mask = 1 << (s & 31);
112
113			if (*cell & mask)
114	pcg	1.28	return 2;
115	pcg	1.2	else
116			{
117			*cell \|= mask;
118	pcg	1.27	return 0;
119	pcg	1.2	}
120			}
121			}
122			};
123
124	root	1.29	typedef callback<const char *()> run_script_cb;
125	pcg	1.5
126			// run a shell script (or actually an external program).
127	pcg	1.26	pid_t run_script (const run_script_cb &cb, bool wait);
128	pcg	1.5
129	pcg	1.7	#if ENABLE_HTTP_PROXY
130			u8 base64_encode (const u8 data, unsigned int len);
131			#endif
132	pcg	1.11
133			/*****************************************************************************/
134
135			typedef u8 rsaclear[RSA_KEYLEN - RSA_OVERHEAD]; // challenge data;
136			typedef u8 rsacrypt[RSA_KEYLEN]; // encrypted challenge
137
138			static inline void
139			rsa_encrypt (RSA *key, const rsaclear &chg, rsacrypt &encr)
140			{
141			if (RSA_public_encrypt (sizeof chg,
142			(unsigned char )&chg, (unsigned char )&encr,
143			key, RSA_PKCS1_OAEP_PADDING) < 0)
144			fatal ("RSA_public_encrypt error");
145			}
146
147			static inline bool
148			rsa_decrypt (RSA *key, const rsacrypt &encr, rsaclear &chg)
149			{
150			return RSA_private_decrypt (sizeof encr,
151			(unsigned char )&encr, (unsigned char )&chg,
152			key, RSA_PKCS1_OAEP_PADDING) > 0;
153			}
154	pcg	1.7
155	root	1.29	/*****************************************************************************/
156
157	root	1.30	// run work_cb in another thread, call done_cb in main thread when finished
158			// only one work_cb will execute at any one time.
159	root	1.29	void async (callback<void ()> work_cb, callback<void ()> done_cb);
160
161	pcg	1.1	#endif
162