added note for tighter sshd config
[feisty_meow.git] / nucleus / library / application / hoople_service.cpp
1 //////////////
2 // Name   : hoople_service
3 // Author : Chris Koeritz
4 //////////////
5 // Copyright (c) 2000-$now By Author.  This program is free software; you can
6 // redistribute it and/or modify it under the terms of the GNU General Public
7 // License as published by the Free Software Foundation:
8 //     http://www.gnu.org/licenses/gpl.html
9 // or under the terms of the GNU Library license:
10 //     http://www.gnu.org/licenses/lgpl.html
11 // at your preference.  Those licenses describe your legal rights to this
12 // software, and no other rights or warranties apply.
13 // Please send updates for this code to: fred@gruntose.com -- Thanks, fred.
14 //////////////
15
16 #include "hoople_service.h"
17
18 #include <basis/array.h>
19 #include <basis/mutex.h>
20 #include <filesystem/filename.h>
21 #include <loggers/program_wide_logger.h>
22 #include <loggers/critical_events.h>
23 #include <processes/process_control.h>
24 #include <processes/process_entry.h>
25 #include <structures/set.h>
26 #include <structures/static_memory_gremlin.h>
27 #include <timely/time_control.h>
28 #include <timely/time_stamp.h>
29 #include <timely/timer_driver.h>
30
31 #include <signal.h>
32
33 using namespace basis;
34 using namespace filesystem;
35 using namespace loggers;
36 using namespace processes;
37 using namespace structures;
38 using namespace timely;
39
40 //#define DEBUG_HOOPLE_SERVICE
41   // uncomment for noisy version.
42
43 #undef LOG
44 #define LOG(s) CLASS_EMERGENCY_LOG(program_wide_logger::get(), s)
45
46 namespace application {
47
48 //////////////
49
50 SAFE_STATIC(astring, hoople_service::_app_name, )
51
52 bool &hoople_service::_defunct() { static bool _defu = false; return _defu; }
53
54 bool &hoople_service::_saw_interrupt()
55 { static bool _saw = false; return _saw; }
56
57 int &hoople_service::_timer_period() { static int _tim = 0; return _tim; }
58
59 //////////////
60
61 static hoople_service *_global_hoople_service = NULL_POINTER;
62   // this static object is set by the setup() method.  it should only come
63   // into existence once during a program's lifetime.
64
65 hoople_service::hoople_service()
66 {
67 }
68
69 hoople_service::~hoople_service()
70 {
71   make_defunct();
72   if (_global_hoople_service) {
73     program_wide_timer().zap_timer(_global_hoople_service);
74   }
75 }
76
77 void hoople_service::handle_startup() { /* nothing for base class. */ }
78
79 void hoople_service::handle_shutdown() { /* nothing for base class. */ }
80
81 void hoople_service::handle_timer() { /* nothing for base class. */ }
82
83 void hoople_service::handle_timer_callback()
84
85   // don't invoke the user's timer unless the object is still alive.
86   if (!is_defunct()) handle_timer();
87 }
88
89 void hoople_service::close_this_program()
90 {
91   make_defunct();
92 }
93
94 bool hoople_service::close_application(const astring &app_name)
95 {
96   FUNCDEF("close_application");
97   process_entry_array procs;
98   process_control querier;
99
100   // lookup process ids of apps.
101   bool got_list = querier.query_processes(procs);
102   if (!got_list) {
103     LOG(astring("couldn't get process list."));
104     return false;
105   }
106   int_set pids;
107   got_list = querier.find_process_in_list(procs, app_name, pids);
108   if (!got_list) {
109     LOG(astring("couldn't find process in the list of active ones."));
110     return true;
111   }
112
113   // zap all of them using our signal.
114   for (int i = 0; i < pids.length(); i++) {
115 //would linux be better served with sigterm also?
116 #ifndef _MSC_VER
117     kill(pids[i], SIGHUP);
118 #else
119 //lame--goes to whole program.
120     raise(SIGTERM);
121 #endif
122 //hmmm: check results...
123   }
124
125   return true;
126 }
127
128 void hoople_service::handle_OS_signal(int formal(sig_id))
129 {
130   _saw_interrupt() = true;  // save the status.
131   if (_global_hoople_service) {
132     _global_hoople_service->close_this_program();
133   }
134 }
135
136 void hoople_service::make_defunct()
137 {
138   _defunct() = true;
139 }
140
141 bool hoople_service::setup(const astring &app_name, int timer_period)
142 {
143 //hmmm: make sure not already initted.
144
145   // simple initializations first...
146   _timer_period() = timer_period;
147   _app_name() = app_name;
148
149   _global_hoople_service = this;
150
151   // setup signal handler for HUP signal.  this is the one used to tell us
152   // to leave.
153 #ifndef _MSC_VER
154   signal(SIGHUP, handle_OS_signal);
155 #endif
156
157   // setup a handler for interrupt (e.g. ctrl-C) also.
158   signal(SIGINT, handle_OS_signal);
159 #ifdef _MSC_VER
160   signal(SIGBREAK, handle_OS_signal);
161 #endif
162
163   return true;
164 }
165
166 bool hoople_service::launch_console(hoople_service &alert,
167     const astring &app_name, int timer_period)
168 {
169 #ifdef DEBUG_HOOPLE_SERVICE
170   FUNCDEF("launch_console");
171 #endif
172   if (!alert.setup(app_name, timer_period)) return false;
173
174   alert.handle_startup();  // tell the program it has started up.
175
176   // start a timer if they requested one.
177   if (_timer_period()) {
178     program_wide_timer().set_timer(_timer_period(), &alert);
179   }
180
181 #ifdef DEBUG_HOOPLE_SERVICE
182   time_stamp next_report(10 * SECOND_ms);
183 #endif
184
185   while (!alert.is_defunct()) {
186 #ifdef DEBUG_HOOPLE_SERVICE
187     if (time_stamp() >= next_report) {
188       printf("%s: shout out from my main thread yo.\n", _global_argv[0]);
189       next_report.reset(10 * SECOND_ms);
190     }
191 #endif
192     time_control::sleep_ms(42);
193   }
194   alert.handle_shutdown();
195   return true;
196 }
197
198 /*
199 #ifdef __WIN32__
200 bool hoople_service::launch_event_loop(hoople_service &alert,
201     const astring &app_name, int timer_period)
202 {
203   if (!alert.setup(app_name, timer_period)) return false;
204   alert.handle_startup();
205
206   if (timer_period)
207     program_wide_timer().set_timer(timer_period, this);
208
209   MSG msg;
210   msg.hwnd = 0; msg.message = 0; msg.wParam = 0; msg.lParam = 0;
211   while (!alert.is_defunct() && (GetMessage(&msg, NULL_POINTER, 0, 0)) {
212     TranslateMessage(&msg);
213     DispatchMessage(&msg);
214   }
215   alert.handle_shutdown();
216
217   return true;
218 }
219 #endif
220 */
221
222 } //namespace.
223