This file is indexed.

/usr/include/tango/lockthread.h is in libtango7-dev 7.2.6+dfsg-4build2.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
//=============================================================================
//
// file :               LockThread.h
//
// description :        Include for the LockThread object. This class implements
//                      the locking thread
//
// project :            TANGO
//
// author(s) :          E.Taurel
//
// Copyright (C) :      2004,2005,2006,2007,2008,2009,2010,2011
//						European Synchrotron Radiation Facility
//                      BP 220, Grenoble 38043
//                      FRANCE
//
// This file is part of Tango.
//
// Tango is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// Tango 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 Lesser General Public License for more details.
// 
// You should have received a copy of the GNU Lesser General Public License
// along with Tango.  If not, see <http://www.gnu.org/licenses/>.
//
// $Revision: 15556 $
//
// $Log$
// Revision 3.8  2010/09/09 13:44:06  taurel
// - Add year 2010 in Copyright notice
//
// Revision 3.7  2009/03/02 15:55:51  taurel
// - Ported to Windows
//
// Revision 3.6  2009/02/27 13:24:43  taurel
// - Small changes for Solaris
//
// Revision 3.5  2009/01/21 12:45:15  taurel
// - Change CopyRights for 2009
//
// Revision 3.4  2008/11/18 09:30:19  taurel
// - Ported to gcc 4.3
// - Removed some cout messages
//
// Revision 3.3  2008/10/06 15:02:17  taurel
// - Changed the licensing info from GPL to LGPL
//
// Revision 3.2  2008/10/02 16:09:25  taurel
// - Add some licensing information in each files...
//
// Revision 3.1  2008/05/20 12:42:30  taurel
// - Commit after merge with release 7 branch
//
// Revision 1.1.2.2  2008/01/03 16:04:23  taurel
// - Some changes in locking feature implementation
//
// Revision 1.1.2.1  2007/12/19 15:53:08  taurel
// - Still some work going on for the locking feature
//
//
// copyleft :           European Synchrotron Radiation Facility
//                      BP 220, Grenoble 38043
//                      FRANCE
//
//=============================================================================

#ifndef _LOCKTHREAD_H
#define _LOCKTHREAD_H

#include <tango.h>
#ifndef _TG_WINDOWS_
#include <sys/time.h>
#endif

namespace Tango
{

//=============================================================================
//
//			The LockThCmd structure
//
// description :	This structure is used to shared data between the locking
//			thread and the main thread.
//
//=============================================================================

struct LockThCmd
{
	bool			cmd_pending;	// The new command flag
	LockCmdCode		cmd_code;		// The command code
	string			dev_name;		// The device name
	DevLong			lock_validity;	// The lock validity
	bool			suicide;		// The suicide flag
};

struct LockedDevice
{
	string			dev_name;		// The locked device name
	DevLong			validity;		// The locked device validity
	
	bool operator<(LockedDevice &arg) {return validity < arg.validity;}
};

enum LockCmdType
{
	LOCK_TIME_OUT = 0,
	LOCK_COMMAND
};

//=============================================================================
//
//			The LockThread class
//
// description :	Class to store all the necessary information for the
//			locking thread. It's run() method is the thread code
//
//=============================================================================

class TangoMonitor;

class LockThread: public omni_thread
{
public:
	LockThread(LockThCmd &,TangoMonitor &,DeviceProxy *,string &,DevLong);
	
	void run(void *);
	
	void execute_cmd();
	void one_more_lock();
	void unlock_all_devs();
	void update_th_period();
	void compute_sleep_time(bool);
	LockCmdType get_command(DevLong);

protected:	
	LockThCmd				&shared_cmd;
	TangoMonitor			&p_mon;

	LockThCmd				local_cmd;
	DevLong					sleep;
	
	vector<LockedDevice>	locked_devices;
	vector<string>			re_lock_cmd_args;
	DevLong					period;
	DevLong 				period_ms;
	DeviceProxy				*admin_proxy;
	
	struct timeval			next_work;
};
	
} // End of Tango namespace

#endif /* _LOCKTHREAD_ */