r23784: use the GPLv3 boilerplate as recommended by the FSF and the license text
[tprouty/samba.git] / source / lib / launchd.c
1 /*
2    Unix SMB/CIFS implementation.
3    Launchd integration wrapper API
4
5    Copyright (C) 2007 James Peach
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "includes.h"
22 #include "smb_launchd.h"
23
24 /* launchd source code and documentation is available here:
25  *      http://launchd.macosforge.org/
26  */
27
28 #if defined(WITH_LAUNCHD_SUPPORT)
29
30 #include <launch.h>
31 #include <stdarg.h>
32
33 typedef void (*launchd_iterator)(launch_data_t, const char*, void*);
34
35 #define LAUNCHD_TRACE_LEVEL 10
36
37  void smb_launchd_checkout(struct smb_launch_info *linfo)
38 {
39         talloc_free(linfo->socket_list);
40 }
41
42 static void pull_launch_sockets(launch_data_t key,
43                                 const char *name,
44                                 struct smb_launch_info *linfo)
45 {
46         launch_data_type_t type;
47
48         type = launch_data_get_type(key);
49         DEBUG(LAUNCHD_TRACE_LEVEL,
50                 ("Searching item name='%s' type=%d for sockets\n",
51                  name ? name : "", (int)type));
52
53         switch (type) {
54         case LAUNCH_DATA_FD:
55                 if (!linfo->socket_list) {
56                         /* We are counting the number of sockets. */
57                         linfo->num_sockets++;
58                 } else {
59                         /* We are collecting the socket fds. */
60                         int fd = launch_data_get_fd(key);
61
62                         linfo->socket_list[linfo->num_sockets] = fd;
63                         linfo->num_sockets++;
64                         DEBUG(LAUNCHD_TRACE_LEVEL,
65                                 ("Added fd=%d to launchd set\n", fd));
66                 }
67                 return;
68         case LAUNCH_DATA_ARRAY:
69         {
70                 int i;
71                 launch_data_t item;
72
73                 for (i = 0; i < launch_data_array_get_count(key); ++i) {
74                         item = launch_data_array_get_index(key, i);
75                         pull_launch_sockets(item, name, linfo);
76                 }
77                 return;
78         }
79         case LAUNCH_DATA_DICTIONARY:
80                 launch_data_dict_iterate(key,
81                         (launchd_iterator)pull_launch_sockets, linfo);
82                 return;
83         default:
84                 return;
85         }
86 }
87
88  BOOL smb_launchd_checkin_names(struct smb_launch_info *linfo, ...)
89 {
90         launch_data_t msg;
91         launch_data_t resp;
92         launch_data_t item;
93         BOOL is_launchd = False;
94
95         ZERO_STRUCTP(linfo);
96
97         msg = launch_data_new_string(LAUNCH_KEY_CHECKIN);
98         resp = launch_msg(msg);
99         if (resp == NULL) {
100                 /* IPC to launchd failed. */
101                 launch_data_free(msg);
102                 return is_launchd;
103         }
104
105         if (launch_data_get_type(resp) == LAUNCH_DATA_ERRNO) {
106                 errno = launch_data_get_errno(resp);
107                 goto done;
108         }
109
110         /* At this point, we know we are running under launchd. */
111         linfo->idle_timeout_secs = 600;
112         is_launchd = True;
113
114         if ((item = launch_data_dict_lookup(resp, LAUNCH_JOBKEY_TIMEOUT))) {
115                 linfo->idle_timeout_secs = launch_data_get_integer(item);
116         }
117
118         if ((item = launch_data_dict_lookup(resp, LAUNCH_JOBKEY_SOCKETS))) {
119                 int count = 0;
120                 const char * sockname = NULL;
121                 launch_data_t sockdata;
122                 va_list args;
123
124                 /* Figure out the maximum number of sockets. */
125                 va_start(args, linfo);
126                 while ((sockname = va_arg(args, const char *))) {
127                     ++count;
128                 }
129                 va_end(args);
130
131                 DEBUG(LAUNCHD_TRACE_LEVEL, ("Found %d launchd sockets\n",
132                                         linfo->num_sockets));
133
134                 if (launch_data_dict_get_count(item) < count) {
135                         DEBUG(0, ("%d launchd sockets requested, "
136                             "but only %d are available\n",
137                             count, launch_data_dict_get_count(item)));
138                 }
139
140                 linfo->socket_list = TALLOC_ARRAY(NULL, int, count);
141                 if (linfo->socket_list == NULL) {
142                         goto done;
143                 }
144
145                 linfo->num_sockets = 0;
146                 va_start(args, linfo);
147                 while ((sockname = va_arg(args, const char *))) {
148                     sockdata = launch_data_dict_lookup(item, sockname);
149
150                     pull_launch_sockets(sockdata, sockname, linfo);
151                     DEBUG(LAUNCHD_TRACE_LEVEL,
152                             ("Added launchd socket \"%s\"\n", sockname));
153                 }
154
155                 SMB_ASSERT(count >= linfo->num_sockets);
156         }
157
158 done:
159         launch_data_free(msg);
160         launch_data_free(resp);
161         return is_launchd;
162 }
163
164  BOOL smb_launchd_checkin(struct smb_launch_info *linfo)
165 {
166         launch_data_t msg;
167         launch_data_t resp;
168         launch_data_t item;
169         BOOL is_launchd = False;
170
171         ZERO_STRUCTP(linfo);
172
173         msg = launch_data_new_string(LAUNCH_KEY_CHECKIN);
174         resp = launch_msg(msg);
175         if (resp == NULL) {
176                 /* IPC to launchd failed. */
177                 launch_data_free(msg);
178                 return is_launchd;
179         }
180
181         if (launch_data_get_type(resp) == LAUNCH_DATA_ERRNO) {
182                 errno = launch_data_get_errno(resp);
183                 goto done;
184         }
185
186         /* At this point, we know we are running under launchd. */
187         linfo->idle_timeout_secs = 600;
188         is_launchd = True;
189
190         if ((item = launch_data_dict_lookup(resp, LAUNCH_JOBKEY_TIMEOUT))) {
191                 linfo->idle_timeout_secs = launch_data_get_integer(item);
192         }
193
194         if ((item = launch_data_dict_lookup(resp, LAUNCH_JOBKEY_SOCKETS))) {
195                 int count;
196
197                 pull_launch_sockets(item, NULL, linfo);
198                 DEBUG(LAUNCHD_TRACE_LEVEL, ("Found %d launchd sockets\n",
199                                         linfo->num_sockets));
200
201                 count = linfo->num_sockets;
202                 linfo->socket_list = TALLOC_ARRAY(NULL, int, count);
203                 if (linfo->socket_list == NULL) {
204                         goto done;
205                 }
206
207                 linfo->num_sockets = 0;
208                 pull_launch_sockets(item, NULL, linfo);
209
210                 DEBUG(LAUNCHD_TRACE_LEVEL, ("Added %d launchd sockets\n",
211                                         linfo->num_sockets));
212
213                 SMB_ASSERT(count == linfo->num_sockets);
214         }
215
216 done:
217         launch_data_free(msg);
218         launch_data_free(resp);
219         return is_launchd;
220 }
221
222 #else /* defined(WITH_LAUNCHD_SUPPORT) */
223
224  BOOL smb_launchd_checkin(struct smb_launch_info * UNUSED(linfo))
225 {
226         ZERO_STRUCTP(linfo);
227         return False;
228 }
229
230  BOOL smb_launchd_checkin_names(struct smb_launch_info * UNUSED(linfo), ...)
231 {
232         ZERO_STRUCTP(linfo);
233         return False;
234 }
235
236  void smb_launchd_checkout(struct smb_launch_info * UNUSED(linfo))
237 {
238 }
239
240 #endif /* defined(WITH_LAUNCHD_SUPPORT) */
241