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-2013 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 "gettext.h"

#include "slog.h"
#include "ev_cpp.h"
#include "callback.h"
#include "global.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);

void hexdump (const char *header, void *data, int len);

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

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

void rand_fill (void *data, int len);

template<class T>
inline void rand_fill (T &t)
{
  rand_fill (&t, sizeof (T));
}

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

// 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.33
Committed:	Wed Jul 17 16:40:58 2013 UTC (10 years, 10 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.32:	+10 -2 lines
Log Message:	* empty log message *
#	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.31	2003-2013 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.15	#include "gettext.h"
41
42	pcg	1.10	#include "slog.h"
43	pcg	1.20	#include "ev_cpp.h"
44			#include "callback.h"
45	root	1.31	#include "global.h"
46	pcg	1.20
47	pcg	1.21	typedef ev_tstamp tstamp;
48	pcg	1.1
49			/*
50	pcg	1.16	* check for an existing gvpe for this net, and write pid to pidfile
51	pcg	1.1	*/
52			extern int write_pidfile (void);
53
54			/*
55	pcg	1.16	* kill older gvpe
56	pcg	1.1	*/
57			extern int kill_other (int signal);
58
59			/*
60			* Detach from current terminal, write pidfile, kill parent
61			*/
62			extern int detach (int do_detach);
63
64			/*
65			* check wether the given path is an absolute pathname
66			*/
67			#define ABSOLUTE_PATH(c) ((c)[0] == '/')
68	pcg	1.10
69	pcg	1.11	/*****************************************************************************/
70
71	pcg	1.10	typedef u8 mac[6];
72	pcg	1.1
73	pcg	1.8	extern void id2mac (unsigned int id, void *m);
74	pcg	1.1
75	pcg	1.8	#define mac2id(p) ((p)[0] & 0x01 ? 0 : ((p)[4] << 8) \| (p)[5])
76	pcg	1.1
77	pcg	1.22	struct sliding_window
78			{
79	pcg	1.2	u32 v[(WINDOWSIZE + 31) / 32];
80			u32 seq;
81
82			void reset (u32 seqno)
83			{
84			memset (v, -1, sizeof v);
85			seq = seqno;
86			}
87
88	pcg	1.28	// 0 == ok, 1 == far history, 2 == duplicate in-window, 3 == far future
89	pcg	1.27	int seqno_classify (u32 seqno)
90	pcg	1.2	{
91			if (seqno <= seq - WINDOWSIZE)
92	pcg	1.27	return 1;
93			else if (seqno > seq + WINDOWSIZE * 16)
94	pcg	1.28	return 3;
95	pcg	1.2	else
96			{
97			while (seqno > seq)
98			{
99			seq++;
100
101			u32 s = seq % WINDOWSIZE;
102			u32 *cell = v + (s >> 5);
103			u32 mask = 1 << (s & 31);
104
105			*cell &= ~mask;
106			}
107
108			u32 s = seqno % WINDOWSIZE;
109			u32 *cell = v + (s >> 5);
110			u32 mask = 1 << (s & 31);
111
112			if (*cell & mask)
113	pcg	1.28	return 2;
114	pcg	1.2	else
115			{
116			*cell \|= mask;
117	pcg	1.27	return 0;
118	pcg	1.2	}
119			}
120			}
121			};
122
123	root	1.29	typedef callback<const char *()> run_script_cb;
124	pcg	1.5
125			// run a shell script (or actually an external program).
126	pcg	1.26	pid_t run_script (const run_script_cb &cb, bool wait);
127	pcg	1.5
128	root	1.32	void hexdump (const char header, void data, int len);
129
130	pcg	1.7	#if ENABLE_HTTP_PROXY
131			u8 base64_encode (const u8 data, unsigned int len);
132			#endif
133	pcg	1.11
134			/*****************************************************************************/
135
136	root	1.33	void rand_fill (void *data, int len);
137
138			template<class T>
139			inline void rand_fill (T &t)
140			{
141			rand_fill (&t, sizeof (T));
142			}
143
144			/*****************************************************************************/
145
146	root	1.30	// run work_cb in another thread, call done_cb in main thread when finished
147			// only one work_cb will execute at any one time.
148	root	1.29	void async (callback<void ()> work_cb, callback<void ()> done_cb);
149
150	pcg	1.1	#endif
151