1 /*****************************************************************************\
2  *  proc_req.c - functions for processing incoming RPCs.
3  *****************************************************************************
4  *  Copyright (C) 2008-2010 Lawrence Livermore National Security.
5  *  Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
6  *  Written by Morris Jette <jette1@llnl.gov>, Danny Auble <da@llnl.gov>
7  *  CODE-OCEC-09-009. All rights reserved.
8  *
9  *  This file is part of Slurm, a resource management program.
10  *  For details, see <https://slurm.schedmd.com/>.
11  *  Please also read the included file: DISCLAIMER.
12  *
13  *  Slurm is free software; you can redistribute it and/or modify it under
14  *  the terms of the GNU General Public License as published by the Free
15  *  Software Foundation; either version 2 of the License, or (at your option)
16  *  any later version.
17  *
18  *  In addition, as a special exception, the copyright holders give permission
19  *  to link the code of portions of this program with the OpenSSL library under
20  *  certain conditions as described in each individual source file, and
21  *  distribute linked combinations including the two. You must obey the GNU
22  *  General Public License in all respects for all of the code used other than
23  *  OpenSSL. If you modify file(s) with this exception, you may extend this
24  *  exception to your version of the file(s), but you are not obligated to do
25  *  so. If you do not wish to do so, delete this exception statement from your
26  *  version.  If you delete this exception statement from all source files in
27  *  the program, then also delete it here.
28  *
29  *  Slurm is distributed in the hope that it will be useful, but WITHOUT ANY
30  *  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
31  *  FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
32  *  details.
33  *
34  *  You should have received a copy of the GNU General Public License along
35  *  with Slurm; if not, write to the Free Software Foundation, Inc.,
36  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA.
37 \*****************************************************************************/
38 
39 #include "config.h"
40 
41 #include <signal.h>
42 
43 #if HAVE_SYS_PRCTL_H
44   #include <sys/prctl.h>
45 #endif
46 
47 #include "src/common/slurm_auth.h"
48 #include "src/common/gres.h"
49 #include "src/common/macros.h"
50 #include "src/common/pack.h"
51 #include "src/common/slurmdbd_defs.h"
52 #include "src/common/slurmdbd_pack.h"
53 #include "src/common/slurm_accounting_storage.h"
54 #include "src/common/slurm_jobacct_gather.h"
55 #include "src/common/slurm_protocol_api.h"
56 #include "src/common/slurm_protocol_defs.h"
57 #include "src/common/timers.h"
58 #include "src/common/uid.h"
59 #include "src/common/xstring.h"
60 #include "src/slurmdbd/read_config.h"
61 #include "src/slurmdbd/rpc_mgr.h"
62 #include "src/slurmdbd/proc_req.h"
63 #include "src/slurmdbd/slurmdbd.h"
64 #include "src/slurmctld/slurmctld.h"
65 
66 /* Local functions */
67 static bool  _validate_slurm_user(uint32_t uid);
68 static bool  _validate_super_user(uint32_t uid, slurmdbd_conn_t *slurmdbd_conn);
69 static bool  _validate_operator(uint32_t uid, slurmdbd_conn_t *slurmdbd_conn);
70 static int   _unpack_persist_init(slurmdbd_conn_t *slurmdbd_conn,
71 				  persist_msg_t *msg, Buf *out_buffer,
72 				  uint32_t *uid);
73 static int   _add_accounts(slurmdbd_conn_t *slurmdbd_conn,
74 			   persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
75 static int   _add_account_coords(slurmdbd_conn_t *slurmdbd_conn,
76 				 persist_msg_t *msg, Buf *out_buffer,
77 				 uint32_t *uid);
78 static int   _add_tres(slurmdbd_conn_t *slurmdbd_conn,
79 		       persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
80 static int   _add_assocs(slurmdbd_conn_t *slurmdbd_conn,
81 			 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
82 static int   _add_clusters(slurmdbd_conn_t *slurmdbd_conn,
83 			   persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
84 static int   _add_federations(slurmdbd_conn_t *slurmdbd_conn,
85 			      persist_msg_t *msg,
86 			      Buf *out_buffer, uint32_t *uid);
87 static int   _add_qos(slurmdbd_conn_t *slurmdbd_conn,
88 		      persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
89 static int   _add_res(slurmdbd_conn_t *slurmdbd_conn,
90 		      persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
91 static int   _add_users(slurmdbd_conn_t *slurmdbd_conn,
92 			persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
93 static int   _add_wckeys(slurmdbd_conn_t *slurmdbd_conn,
94 			 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
95 static int   _add_reservation(slurmdbd_conn_t *slurmdbd_conn,
96 			      persist_msg_t *msg, Buf *out_buffer,
97 			      uint32_t *uid);
98 static int   _archive_dump(slurmdbd_conn_t *slurmdbd_conn,
99 			   persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
100 static int   _archive_load(slurmdbd_conn_t *slurmdbd_conn,
101 			   persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
102 static int   _clear_stats(slurmdbd_conn_t *slurmdbd_conn,
103 			  persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
104 static int   _cluster_tres(slurmdbd_conn_t *slurmdbd_conn,
105 			   persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
106 static int   _fix_runaway_jobs(slurmdbd_conn_t *slurmdbd_conn,
107 			       persist_msg_t *msg,
108 			       Buf *out_buffer, uint32_t *uid);
109 static int   _get_accounts(slurmdbd_conn_t *slurmdbd_conn,
110 			   persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
111 static int   _get_tres(slurmdbd_conn_t *slurmdbd_conn,
112 		       persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
113 static int   _get_assocs(slurmdbd_conn_t *slurmdbd_conn,
114 			 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
115 static int   _get_clusters(slurmdbd_conn_t *slurmdbd_conn,
116 			   persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
117 static int   _get_federations(slurmdbd_conn_t *slurmdbd_conn,
118 			      persist_msg_t *msg,
119 			      Buf *out_buffer, uint32_t *uid);
120 static int   _get_config(slurmdbd_conn_t *slurmdbd_conn,
121 			 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
122 static int   _get_events(slurmdbd_conn_t *slurmdbd_conn,
123 			 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
124 static int   _get_jobs_cond(slurmdbd_conn_t *slurmdbd_conn,
125 			    persist_msg_t *msg, Buf *out_buffer,
126 			    uint32_t *uid);
127 static int   _get_probs(slurmdbd_conn_t *slurmdbd_conn,
128 			persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
129 static int   _get_qos(slurmdbd_conn_t *slurmdbd_conn,
130 		      persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
131 static int   _get_res(slurmdbd_conn_t *slurmdbd_conn,
132 		      persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
133 static int   _get_stats(slurmdbd_conn_t *slurmdbd_conn,
134 		        persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
135 static int   _get_txn(slurmdbd_conn_t *slurmdbd_conn,
136 		      persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
137 static int   _get_usage(slurmdbd_conn_t *slurmdbd_conn,
138 			persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
139 static int   _get_users(slurmdbd_conn_t *slurmdbd_conn,
140 			persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
141 static int   _get_wckeys(slurmdbd_conn_t *slurmdbd_conn,
142 			 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
143 static int   _get_reservations(slurmdbd_conn_t *slurmdbd_conn,
144 			       persist_msg_t *msg, Buf *out_buffer,
145 			       uint32_t *uid);
146 static int   _find_rpc_obj_in_list(void *x, void *key);
147 static int   _flush_jobs(slurmdbd_conn_t *slurmdbd_conn,
148 			 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
149 static int   _fini_conn(slurmdbd_conn_t *slurmdbd_conn, persist_msg_t *msg,
150 			Buf *out_buffer);
151 static int   _job_complete(slurmdbd_conn_t *slurmdbd_conn,
152 			   persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
153 static int   _job_start(slurmdbd_conn_t *slurmdbd_conn,
154 			persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
155 static int   _job_suspend(slurmdbd_conn_t *slurmdbd_conn,
156 			  persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
157 static int   _modify_accounts(slurmdbd_conn_t *slurmdbd_conn,
158 			      persist_msg_t *msg, Buf *out_buffer,
159 			      uint32_t *uid);
160 static int   _modify_assocs(slurmdbd_conn_t *slurmdbd_conn,
161 			    persist_msg_t *msg, Buf *out_buffer,
162 			    uint32_t *uid);
163 static int   _modify_clusters(slurmdbd_conn_t *slurmdbd_conn,
164 			      persist_msg_t *msg, Buf *out_buffer,
165 			      uint32_t *uid);
166 static int   _modify_federations(slurmdbd_conn_t *slurmdbd_conn,
167 				 persist_msg_t *msg,
168 				 Buf *out_buffer, uint32_t *uid);
169 static int   _modify_job(slurmdbd_conn_t *slurmdbd_conn,
170 			 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
171 static int   _modify_qos(slurmdbd_conn_t *slurmdbd_conn,
172 			 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
173 static int   _modify_res(slurmdbd_conn_t *slurmdbd_conn,
174 			 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
175 static int   _modify_users(slurmdbd_conn_t *slurmdbd_conn,
176 			   persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
177 static int   _modify_wckeys(slurmdbd_conn_t *slurmdbd_conn,
178 			    persist_msg_t *msg, Buf *out_buffer,
179 			    uint32_t *uid);
180 static int   _modify_reservation(slurmdbd_conn_t *slurmdbd_conn,
181 				 persist_msg_t *msg, Buf *out_buffer,
182 				 uint32_t *uid);
183 static int   _node_state(slurmdbd_conn_t *slurmdbd_conn,
184 			 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
185 static void  _process_job_start(slurmdbd_conn_t *slurmdbd_conn,
186 				dbd_job_start_msg_t *job_start_msg,
187 				dbd_id_rc_msg_t *id_rc_msg);
188 static int   _reconfig(slurmdbd_conn_t *slurmdbd_conn,
189 		       persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
190 static int   _register_ctld(slurmdbd_conn_t *slurmdbd_conn,
191 			    persist_msg_t *msg, Buf *out_buffer,
192 			    uint32_t *uid);
193 static int   _remove_accounts(slurmdbd_conn_t *slurmdbd_conn,
194 			      persist_msg_t *msg, Buf *out_buffer,
195 			      uint32_t *uid);
196 static int   _remove_account_coords(slurmdbd_conn_t *slurmdbd_conn,
197 				    persist_msg_t *msg, Buf *out_buffer,
198 				    uint32_t *uid);
199 static int   _remove_assocs(slurmdbd_conn_t *slurmdbd_conn,
200 			    persist_msg_t *msg, Buf *out_buffer,
201 			    uint32_t *uid);
202 static int   _remove_clusters(slurmdbd_conn_t *slurmdbd_conn,
203 			      persist_msg_t *msg, Buf *out_buffer,
204 			      uint32_t *uid);
205 static int   _remove_federations(slurmdbd_conn_t *slurmdbd_conn,
206 				 persist_msg_t *msg,
207 				 Buf *out_buffer, uint32_t *uid);
208 static int   _remove_qos(slurmdbd_conn_t *slurmdbd_conn,
209 			 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
210 static int   _remove_res(slurmdbd_conn_t *slurmdbd_conn,
211 			 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
212 static int   _remove_users(slurmdbd_conn_t *slurmdbd_conn,
213 			   persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
214 static int   _remove_wckeys(slurmdbd_conn_t *slurmdbd_conn,
215 			    persist_msg_t *msg, Buf *out_buffer,
216 			    uint32_t *uid);
217 static int   _remove_reservation(slurmdbd_conn_t *slurmdbd_conn,
218 				 persist_msg_t *msg, Buf *out_buffer,
219 				 uint32_t *uid);
220 static int   _roll_usage(slurmdbd_conn_t *slurmdbd_conn,
221 			 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
222 static int   _send_mult_job_start(slurmdbd_conn_t *slurmdbd_conn,
223 				  persist_msg_t *msg, Buf *out_buffer,
224 				  uint32_t *uid);
225 static int   _send_mult_msg(slurmdbd_conn_t *slurmdbd_conn,
226 			    persist_msg_t *msg, Buf *out_buffer,
227 			    uint32_t *uid);
228 static int   _shutdown(slurmdbd_conn_t *slurmdbd_conn,
229 		       persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
230 static int   _step_complete(slurmdbd_conn_t *slurmdbd_conn,
231 			    persist_msg_t *msg, Buf *out_buffer,
232 			    uint32_t *uid);
233 static int   _step_start(slurmdbd_conn_t *slurmdbd_conn,
234 			 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid);
235 
236 #ifndef NDEBUG
237 /*
238  * Used alongside the testsuite to signal that the RPC should be processed
239  * as an untrusted user, rather than the "real" account. (Which in a lot of
240  * testing is likely SlurmUser, and thus allowed to bypass many security
241  * checks.
242  *
243  * Implemented with a thread-local variable to apply only to the current
244  * RPC handling thread. Set by SLURM_DROP_PRIV bit in the slurm_msg_t flags.
245  */
246 __thread bool drop_priv = false;
247 #endif
248 
249 /* Process an incoming RPC
250  * slurmdbd_conn IN/OUT - in will that the conn.fd set before
251  *       calling and db_conn and conn.version will be filled in with the init.
252  * msg IN - incoming message
253  * msg_size IN - size of msg in bytes
254  * first IN - set if first message received on the socket
255  * buffer OUT - outgoing response, must be freed by caller
256  * uid IN/OUT - user ID who initiated the RPC
257  * RET SLURM_SUCCESS or error code */
258 extern int
proc_req(void * conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)259 proc_req(void *conn, persist_msg_t *msg,
260 	 Buf *out_buffer, uint32_t *uid)
261 {
262 	slurmdbd_conn_t *slurmdbd_conn = conn;
263 	int rc = SLURM_SUCCESS;
264 	char *comment = NULL;
265 	slurmdb_rpc_obj_t *rpc_obj;
266 
267 	DEF_TIMERS;
268 	START_TIMER;
269 
270 	switch (msg->msg_type) {
271 	case REQUEST_PERSIST_INIT:
272 		rc = _unpack_persist_init(
273 			slurmdbd_conn, msg, out_buffer, uid);
274 		break;
275 	case DBD_ADD_ACCOUNTS:
276 		rc = _add_accounts(slurmdbd_conn,
277 				   msg, out_buffer, uid);
278 		break;
279 	case DBD_ADD_ACCOUNT_COORDS:
280 		rc = _add_account_coords(slurmdbd_conn,
281 					 msg, out_buffer, uid);
282 		break;
283 	case DBD_ADD_TRES:
284 		rc = _add_tres(slurmdbd_conn,
285 			       msg, out_buffer, uid);
286 		break;
287 	case DBD_ADD_ASSOCS:
288 		rc = _add_assocs(slurmdbd_conn,
289 				 msg, out_buffer, uid);
290 		break;
291 	case DBD_ADD_CLUSTERS:
292 		rc = _add_clusters(slurmdbd_conn,
293 				   msg, out_buffer, uid);
294 		break;
295 	case DBD_ADD_FEDERATIONS:
296 		rc = _add_federations(slurmdbd_conn, msg,
297 				      out_buffer, uid);
298 		break;
299 	case DBD_ADD_QOS:
300 		rc = _add_qos(slurmdbd_conn,
301 			      msg, out_buffer, uid);
302 		break;
303 	case DBD_ADD_RES:
304 		rc = _add_res(slurmdbd_conn,
305 			      msg, out_buffer, uid);
306 		break;
307 	case DBD_ADD_USERS:
308 		rc = _add_users(slurmdbd_conn,
309 				msg, out_buffer, uid);
310 		break;
311 	case DBD_ADD_WCKEYS:
312 		rc = _add_wckeys(slurmdbd_conn,
313 				 msg, out_buffer, uid);
314 		break;
315 	case DBD_ADD_RESV:
316 		rc = _add_reservation(slurmdbd_conn,
317 				      msg, out_buffer, uid);
318 		break;
319 	case DBD_ARCHIVE_DUMP:
320 		rc = _archive_dump(slurmdbd_conn,
321 				   msg, out_buffer, uid);
322 		break;
323 	case DBD_ARCHIVE_LOAD:
324 		rc = _archive_load(slurmdbd_conn,
325 				   msg, out_buffer, uid);
326 		break;
327 	case DBD_CLUSTER_TRES:
328 		rc = _cluster_tres(slurmdbd_conn,
329 				   msg, out_buffer, uid);
330 		break;
331 	case DBD_GET_ACCOUNTS:
332 		rc = _get_accounts(slurmdbd_conn,
333 				   msg, out_buffer, uid);
334 		break;
335 	case DBD_GET_TRES:
336 		rc = _get_tres(slurmdbd_conn,
337 			       msg, out_buffer, uid);
338 		break;
339 	case DBD_GET_ASSOCS:
340 		rc = _get_assocs(slurmdbd_conn,
341 				 msg, out_buffer, uid);
342 		break;
343 	case DBD_GET_ASSOC_USAGE:
344 	case DBD_GET_WCKEY_USAGE:
345 	case DBD_GET_CLUSTER_USAGE:
346 		rc = _get_usage(slurmdbd_conn,
347 				msg, out_buffer, uid);
348 		break;
349 	case DBD_GET_CLUSTERS:
350 		rc = _get_clusters(slurmdbd_conn,
351 				   msg, out_buffer, uid);
352 		break;
353 	case DBD_GET_FEDERATIONS:
354 		rc = _get_federations(slurmdbd_conn, msg,
355 				      out_buffer, uid);
356 		break;
357 	case DBD_GET_CONFIG:
358 		rc = _get_config(slurmdbd_conn,
359 				 msg, out_buffer, uid);
360 		break;
361 	case DBD_GET_EVENTS:
362 		rc = _get_events(slurmdbd_conn,
363 				 msg, out_buffer, uid);
364 		break;
365 	case DBD_GET_JOBS_COND:
366 		rc = _get_jobs_cond(slurmdbd_conn,
367 				    msg, out_buffer, uid);
368 		break;
369 	case DBD_GET_PROBS:
370 		rc = _get_probs(slurmdbd_conn,
371 				msg, out_buffer, uid);
372 		break;
373 	case DBD_GET_QOS:
374 		rc = _get_qos(slurmdbd_conn,
375 			      msg, out_buffer, uid);
376 		break;
377 	case DBD_GET_RES:
378 		rc = _get_res(slurmdbd_conn,
379 			      msg, out_buffer, uid);
380 		break;
381 	case DBD_GET_TXN:
382 		rc = _get_txn(slurmdbd_conn,
383 			      msg, out_buffer, uid);
384 		break;
385 	case DBD_GET_WCKEYS:
386 		rc = _get_wckeys(slurmdbd_conn,
387 				 msg, out_buffer, uid);
388 		break;
389 	case DBD_GET_RESVS:
390 		rc = _get_reservations(slurmdbd_conn,
391 				       msg, out_buffer, uid);
392 		break;
393 	case DBD_GET_USERS:
394 		rc = _get_users(slurmdbd_conn,
395 				msg, out_buffer, uid);
396 		break;
397 	case DBD_FLUSH_JOBS:
398 		rc = _flush_jobs(slurmdbd_conn,
399 				 msg, out_buffer, uid);
400 		break;
401 	case DBD_FINI:
402 		rc = _fini_conn(slurmdbd_conn, msg, out_buffer);
403 		break;
404 	case DBD_JOB_COMPLETE:
405 		rc = _job_complete(slurmdbd_conn,
406 				   msg, out_buffer, uid);
407 		break;
408 	case DBD_JOB_START:
409 		rc = _job_start(slurmdbd_conn,
410 				msg, out_buffer, uid);
411 		break;
412 	case DBD_JOB_SUSPEND:
413 		rc = _job_suspend(slurmdbd_conn,
414 				  msg, out_buffer, uid);
415 		break;
416 	case DBD_MODIFY_ACCOUNTS:
417 		rc = _modify_accounts(slurmdbd_conn,
418 				      msg, out_buffer, uid);
419 		break;
420 	case DBD_MODIFY_ASSOCS:
421 		rc = _modify_assocs(slurmdbd_conn,
422 				    msg, out_buffer, uid);
423 		break;
424 	case DBD_MODIFY_CLUSTERS:
425 		rc = _modify_clusters(slurmdbd_conn,
426 				      msg, out_buffer, uid);
427 		break;
428 	case DBD_MODIFY_FEDERATIONS:
429 		rc = _modify_federations(slurmdbd_conn, msg,
430 					 out_buffer, uid);
431 		break;
432 	case DBD_MODIFY_JOB:
433 		rc = _modify_job(slurmdbd_conn,
434 				 msg, out_buffer, uid);
435 		break;
436 	case DBD_MODIFY_QOS:
437 		rc = _modify_qos(slurmdbd_conn,
438 				 msg, out_buffer, uid);
439 		break;
440 	case DBD_MODIFY_RES:
441 		rc = _modify_res(slurmdbd_conn,
442 				 msg, out_buffer, uid);
443 		break;
444 	case DBD_MODIFY_USERS:
445 		rc = _modify_users(slurmdbd_conn,
446 				   msg, out_buffer, uid);
447 		break;
448 	case DBD_MODIFY_WCKEYS:
449 		rc = _modify_wckeys(slurmdbd_conn,
450 				    msg, out_buffer, uid);
451 		break;
452 	case DBD_MODIFY_RESV:
453 		rc = _modify_reservation(slurmdbd_conn,
454 					 msg, out_buffer, uid);
455 		break;
456 	case DBD_NODE_STATE:
457 		rc = _node_state(slurmdbd_conn,
458 				 msg, out_buffer, uid);
459 		break;
460 	case DBD_RECONFIG:
461 		/* handle reconfig */
462 		rc = _reconfig(slurmdbd_conn,
463 			       msg, out_buffer, uid);
464 		break;
465 	case DBD_REGISTER_CTLD:
466 		rc = _register_ctld(slurmdbd_conn, msg,
467 				    out_buffer, uid);
468 		break;
469 	case DBD_REMOVE_ACCOUNTS:
470 		rc = _remove_accounts(slurmdbd_conn,
471 				      msg, out_buffer, uid);
472 		break;
473 	case DBD_REMOVE_ACCOUNT_COORDS:
474 		rc = _remove_account_coords(slurmdbd_conn,
475 					    msg, out_buffer, uid);
476 		break;
477 	case DBD_REMOVE_ASSOCS:
478 		rc = _remove_assocs(slurmdbd_conn,
479 				    msg, out_buffer, uid);
480 		break;
481 	case DBD_REMOVE_CLUSTERS:
482 		rc = _remove_clusters(slurmdbd_conn,
483 				      msg, out_buffer, uid);
484 		break;
485 	case DBD_REMOVE_FEDERATIONS:
486 		rc = _remove_federations(slurmdbd_conn, msg,
487 					 out_buffer, uid);
488 		break;
489 	case DBD_REMOVE_QOS:
490 		rc = _remove_qos(slurmdbd_conn,
491 				 msg, out_buffer, uid);
492 		break;
493 	case DBD_REMOVE_RES:
494 		rc = _remove_res(slurmdbd_conn,
495 				 msg, out_buffer, uid);
496 		break;
497 	case DBD_REMOVE_USERS:
498 		rc = _remove_users(slurmdbd_conn,
499 				   msg, out_buffer, uid);
500 		break;
501 	case DBD_REMOVE_WCKEYS:
502 		rc = _remove_wckeys(slurmdbd_conn,
503 				    msg, out_buffer, uid);
504 		break;
505 	case DBD_REMOVE_RESV:
506 		rc = _remove_reservation(slurmdbd_conn,
507 					 msg, out_buffer, uid);
508 		break;
509 	case DBD_ROLL_USAGE:
510 		rc = _roll_usage(slurmdbd_conn,
511 				 msg, out_buffer, uid);
512 		break;
513 	case DBD_SEND_MULT_JOB_START:
514 		rc = _send_mult_job_start(slurmdbd_conn,
515 					  msg, out_buffer, uid);
516 		break;
517 	case DBD_SEND_MULT_MSG:
518 		rc = _send_mult_msg(slurmdbd_conn,
519 				    msg, out_buffer, uid);
520 		break;
521 	case DBD_STEP_COMPLETE:
522 		rc = _step_complete(slurmdbd_conn,
523 				    msg, out_buffer, uid);
524 		break;
525 	case DBD_STEP_START:
526 		rc = _step_start(slurmdbd_conn,
527 				 msg, out_buffer, uid);
528 		break;
529 	case DBD_FIX_RUNAWAY_JOB:
530 		rc = _fix_runaway_jobs(slurmdbd_conn,
531 				       msg, out_buffer, uid);
532 		break;
533 	case DBD_GET_STATS:
534 		rc = _get_stats(slurmdbd_conn, msg, out_buffer,
535 				uid);
536 		break;
537 	case DBD_CLEAR_STATS:
538 		rc = _clear_stats(slurmdbd_conn, msg, out_buffer,
539 				  uid);
540 		break;
541 	case DBD_SHUTDOWN:
542 		rc = _shutdown(slurmdbd_conn, msg, out_buffer,
543 			       uid);
544 		break;
545 	default:
546 		comment = "Invalid RPC";
547 		error("CONN:%u %s msg_type=%d",
548 		      slurmdbd_conn->conn->fd, comment, msg->msg_type);
549 		rc = EINVAL;
550 		*out_buffer = slurm_persist_make_rc_msg(
551 			slurmdbd_conn->conn, rc, comment, 0);
552 		break;
553 	}
554 
555 	if (rc == ESLURM_ACCESS_DENIED)
556 		error("CONN:%u Security violation, %s",
557 		      slurmdbd_conn->conn->fd,
558 		      slurmdbd_msg_type_2_str(msg->msg_type, 1));
559 	else if (slurmdbd_conn->conn->rem_port
560 		 && !slurmdbd_conf->commit_delay) {
561 		/* If we are dealing with the slurmctld do the
562 		   commit (SUCCESS or NOT) afterwards since we
563 		   do transactions for performance reasons.
564 		   (don't ever use autocommit with innodb)
565 		*/
566 		acct_storage_g_commit(slurmdbd_conn->db_conn, 1);
567 	}
568 
569 	END_TIMER;
570 
571 	slurm_mutex_lock(&rpc_mutex);
572 
573 	if (!(rpc_obj = list_find_first(rpc_stats.rpc_list,
574 					_find_rpc_obj_in_list,
575 					&msg->msg_type))) {
576 		rpc_obj = xmalloc(sizeof(slurmdb_rpc_obj_t));
577 		rpc_obj->id = msg->msg_type;
578 		list_append(rpc_stats.rpc_list, rpc_obj);
579 	}
580 	rpc_obj->cnt++;
581 	rpc_obj->time += DELTA_TIMER;
582 
583 	if (!(rpc_obj = list_find_first(rpc_stats.user_list,
584 					_find_rpc_obj_in_list,
585 					uid))) {
586 		rpc_obj = xmalloc(sizeof(slurmdb_rpc_obj_t));
587 		rpc_obj->id = *uid;
588 		list_append(rpc_stats.user_list, rpc_obj);
589 	}
590 	rpc_obj->cnt++;
591 	rpc_obj->time += DELTA_TIMER;
592 
593 	slurm_mutex_unlock(&rpc_mutex);
594 
595 	return rc;
596 }
597 
598 /*
599  * _validate_slurm_user - validate that the uid is authorized to see
600  *      privileged data (either user root or SlurmUser)
601  */
_validate_slurm_user(uint32_t uid)602 static bool _validate_slurm_user(uint32_t uid)
603 {
604 #ifndef NDEBUG
605 	if (drop_priv)
606 		return false;
607 #endif
608 	if ((uid == 0) || (uid == slurmdbd_conf->slurm_user_id))
609 		return true;
610 
611 	return false;
612 }
613 
614 /*
615  * _validate_super_user - validate that the uid is authorized at the
616  *      root, SlurmUser, or SLURMDB_ADMIN_SUPER_USER level
617  */
_validate_super_user(uint32_t uid,slurmdbd_conn_t * dbd_conn)618 static bool _validate_super_user(uint32_t uid, slurmdbd_conn_t *dbd_conn)
619 {
620 #ifndef NDEBUG
621 	if (drop_priv)
622 		return false;
623 #endif
624 	if ((uid == 0) || (uid == slurmdbd_conf->slurm_user_id) ||
625 	    assoc_mgr_get_admin_level(dbd_conn, uid) >= SLURMDB_ADMIN_SUPER_USER)
626 		return true;
627 
628 	return false;
629 }
630 
631 /*
632  * _validate_operator - validate that the uid is authorized at the
633  *      root, SlurmUser, or SLURMDB_ADMIN_OPERATOR level
634  */
_validate_operator(uint32_t uid,slurmdbd_conn_t * dbd_conn)635 static bool _validate_operator(uint32_t uid, slurmdbd_conn_t *dbd_conn)
636 {
637 #ifndef NDEBUG
638 	if (drop_priv)
639 		return false;
640 #endif
641 	if ((uid == 0) || (uid == slurmdbd_conf->slurm_user_id) ||
642 	    assoc_mgr_get_admin_level(dbd_conn, uid) >= SLURMDB_ADMIN_OPERATOR)
643 		return true;
644 
645 	return false;
646 }
647 
_add_registered_cluster(slurmdbd_conn_t * db_conn)648 static void _add_registered_cluster(slurmdbd_conn_t *db_conn)
649 {
650 	ListIterator itr;
651 	slurmdbd_conn_t *slurmdbd_conn;
652 
653 	if (!db_conn->conn->rem_port) {
654 		error("%s: trying to register a cluster (%s) with no remote port",
655 		      __func__, db_conn->conn->cluster_name);
656 		return;
657 	}
658 
659 	slurm_mutex_lock(&registered_lock);
660 	itr = list_iterator_create(registered_clusters);
661 	while ((slurmdbd_conn = list_next(itr))) {
662 		if (db_conn == slurmdbd_conn)
663 			break;
664 
665 		if (!xstrcmp(db_conn->conn->cluster_name,
666 			     slurmdbd_conn->conn->cluster_name) &&
667 		    (db_conn->conn->fd != slurmdbd_conn->conn->fd)) {
668 			error("A new registration for cluster %s CONN:%d just came in, but I am already talking to that cluster (CONN:%d), closing other connection.",
669 			      db_conn->conn->cluster_name, db_conn->conn->fd,
670 			      slurmdbd_conn->conn->fd);
671 			slurmdbd_conn->conn->rem_port = 0;
672 			list_delete_item(itr);
673 		}
674 	}
675 	list_iterator_destroy(itr);
676 	if (!slurmdbd_conn)
677 		list_append(registered_clusters, db_conn);
678 	slurm_mutex_unlock(&registered_lock);
679 }
680 
681 
682 /* replace \" with \` return is the same as what is given */
_replace_double_quotes(char * option)683 static char * _replace_double_quotes(char *option)
684 {
685 	int i=0;
686 
687 	if (!option)
688 		return NULL;
689 
690 	while (option[i]) {
691 		if (option[i] == '\"')
692 			option[i] = '`';
693 		i++;
694 	}
695 	return option;
696 }
697 
_handle_init_msg(slurmdbd_conn_t * slurmdbd_conn,persist_init_req_msg_t * init_msg,uint32_t * uid)698 static int _handle_init_msg(slurmdbd_conn_t *slurmdbd_conn,
699 			    persist_init_req_msg_t *init_msg,
700 			    uint32_t *uid)
701 {
702 	int rc = SLURM_SUCCESS;
703 
704 	*uid = init_msg->uid;
705 
706 #if HAVE_SYS_PRCTL_H
707 	{
708 	char *name = xstrdup_printf("p-%s", init_msg->cluster_name);
709 	if (prctl(PR_SET_NAME, name, NULL, NULL, NULL) < 0)
710 		error("%s: cannot set my name to %s %m", __func__, name);
711 	xfree(name);
712 	}
713 #endif
714 
715 	debug("REQUEST_PERSIST_INIT: CLUSTER:%s VERSION:%u UID:%u IP:%s CONN:%u",
716 	      init_msg->cluster_name, init_msg->version, init_msg->uid,
717 	      slurmdbd_conn->conn->rem_host, slurmdbd_conn->conn->fd);
718 
719 	slurmdbd_conn->conn->cluster_name = xstrdup(init_msg->cluster_name);
720 
721 	/* When dealing with rollbacks it turns out it is much faster
722 	   to do the commit once or once in a while instead of
723 	   autocommit.  The SlurmDBD will periodically do a commit to
724 	   avoid such a slow down.
725 	*/
726 	slurmdbd_conn->db_conn = acct_storage_g_get_connection(
727 		NULL, slurmdbd_conn->conn->fd, NULL, true,
728 		slurmdbd_conn->conn->cluster_name);
729 	slurmdbd_conn->conn->version = init_msg->version;
730 	if (errno)
731 		rc = errno;
732 
733 	return rc;
734 }
735 
_unpack_persist_init(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)736 static int _unpack_persist_init(slurmdbd_conn_t *slurmdbd_conn,
737 				persist_msg_t *msg, Buf *out_buffer,
738 				uint32_t *uid)
739 {
740 	int rc;
741 	slurm_msg_t *smsg = msg->data;
742 	persist_init_req_msg_t *req_msg = smsg->data;
743 	char *comment = NULL;
744 
745 #ifndef NDEBUG
746 	if ((smsg->flags & SLURM_DROP_PRIV))
747 		drop_priv = true;
748 #endif
749 
750 	req_msg->uid = g_slurm_auth_get_uid(slurmdbd_conn->conn->auth_cred);
751 
752 	/* If the client happens to be a newer version than we are make it so
753 	 * they talk language I understand.
754 	 */
755 	if (req_msg->version > SLURM_PROTOCOL_VERSION)
756 		req_msg->version = SLURM_PROTOCOL_VERSION;
757 
758 	rc = _handle_init_msg(slurmdbd_conn, req_msg, uid);
759 
760 	if (rc != SLURM_SUCCESS)
761 		comment = slurm_strerror(rc);
762 
763 	*out_buffer = slurm_persist_make_rc_msg_flags(
764 		slurmdbd_conn->conn, rc, comment,
765 		slurmdbd_conf->persist_conn_rc_flags,
766 		req_msg->version);
767 
768 	return rc;
769 }
770 
_add_accounts(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)771 static int _add_accounts(slurmdbd_conn_t *slurmdbd_conn,
772 			 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
773 {
774 	int rc = SLURM_SUCCESS;
775 	dbd_list_msg_t *get_msg = msg->data;
776 	char *comment = NULL;
777 
778 	debug2("DBD_ADD_ACCOUNTS: called");
779 
780 	rc = acct_storage_g_add_accounts(slurmdbd_conn->db_conn, *uid,
781 					 get_msg->my_list);
782 	if (rc == ESLURM_ACCESS_DENIED)
783 		comment = "Your user doesn't have privilege to perform this action";
784 	*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
785 						rc, comment, DBD_ADD_ACCOUNTS);
786 	return rc;
787 }
788 
_fix_runaway_jobs(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)789 static int _fix_runaway_jobs(slurmdbd_conn_t *slurmdbd_conn, persist_msg_t *msg,
790 			     Buf *out_buffer, uint32_t *uid)
791 {
792 	int rc = SLURM_SUCCESS;
793 	dbd_list_msg_t *get_msg = msg->data;
794 	char *comment = NULL;
795 
796 	if (!_validate_operator(*uid, slurmdbd_conn))
797 		rc = ESLURM_ACCESS_DENIED;
798 	else
799 		rc = acct_storage_g_fix_runaway_jobs(
800 			slurmdbd_conn->db_conn, *uid, get_msg->my_list);
801 
802 	if (rc == ESLURM_ACCESS_DENIED) {
803 		comment = "You must have an AdminLevel>=Operator to fix runaway jobs";
804 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
805 	}
806 
807 	*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
808 						rc, comment,
809 						DBD_FIX_RUNAWAY_JOB);
810 
811 	return rc;
812 }
813 
_add_account_coords(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)814 static int _add_account_coords(slurmdbd_conn_t *slurmdbd_conn,
815 			       persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
816 {
817 	int rc = SLURM_SUCCESS;
818 	dbd_acct_coord_msg_t *get_msg = msg->data;
819 	char *comment = NULL;
820 
821 	debug2("DBD_ADD_ACCOUNT_COORDS: called");
822 
823 	rc = acct_storage_g_add_coord(slurmdbd_conn->db_conn, *uid,
824 				      get_msg->acct_list, get_msg->cond);
825 
826 	if (rc == ESLURM_ACCESS_DENIED) {
827 		comment = "Your user doesn't have privilege to perform this action";
828 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
829 	}
830 
831 	*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
832 						rc, comment,
833 						DBD_ADD_ACCOUNT_COORDS);
834 	return rc;
835 }
836 
_add_tres(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)837 static int _add_tres(slurmdbd_conn_t *slurmdbd_conn,
838 		     persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
839 {
840 	int rc = SLURM_SUCCESS;
841 	dbd_list_msg_t *get_msg = msg->data;
842 	char *comment = NULL;
843 
844 	debug2("DBD_ADD_TRES: called");
845 
846 	rc = acct_storage_g_add_tres(slurmdbd_conn->db_conn, *uid,
847 				     get_msg->my_list);
848 
849 	*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
850 						rc, comment, DBD_ADD_TRES);
851 
852 	/* This happens before the slurmctld registers and only when
853 	   the slurmctld starts up.  So always commit, success or not.
854 	   (don't ever use autocommit with innodb)
855 	*/
856 	acct_storage_g_commit(slurmdbd_conn->db_conn, 1);
857 
858 	return rc;
859 }
860 
_add_assocs(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)861 static int _add_assocs(slurmdbd_conn_t *slurmdbd_conn,
862 		       persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
863 {
864 	int rc = SLURM_SUCCESS;
865 	dbd_list_msg_t *get_msg = msg->data;
866 	char *comment = NULL;
867 
868 	debug2("DBD_ADD_ASSOCS: called");
869 
870 	if (!_validate_operator(*uid, slurmdbd_conn)) {
871 		ListIterator itr = NULL;
872 		ListIterator itr2 = NULL;
873 		slurmdb_user_rec_t user;
874 		slurmdb_coord_rec_t *coord = NULL;
875 		slurmdb_assoc_rec_t *object = NULL;
876 
877 		memset(&user, 0, sizeof(slurmdb_user_rec_t));
878 		user.uid = *uid;
879 		if (assoc_mgr_fill_in_user(
880 			    slurmdbd_conn->db_conn, &user, 1, NULL, false)
881 		    != SLURM_SUCCESS) {
882 			comment = "Your user has not been added to the accounting system yet.";
883 			error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
884 			rc = SLURM_ERROR;
885 			goto end_it;
886 		}
887 		if (!user.coord_accts || !list_count(user.coord_accts)) {
888 			comment = "Your user doesn't have privilege to perform this action";
889 			error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
890 			rc = ESLURM_ACCESS_DENIED;
891 			goto end_it;
892 		}
893 		itr = list_iterator_create(get_msg->my_list);
894 		itr2 = list_iterator_create(user.coord_accts);
895 		while ((object = list_next(itr))) {
896 			char *account = "root";
897 			if (object->user)
898 				account = object->acct;
899 			else if (object->parent_acct)
900 				account = object->parent_acct;
901 			list_iterator_reset(itr2);
902 			while ((coord = list_next(itr2))) {
903 				if (!xstrcasecmp(coord->name, account))
904 					break;
905 			}
906 			if (!coord)
907 				break;
908 		}
909 		list_iterator_destroy(itr2);
910 		list_iterator_destroy(itr);
911 		if (!coord)  {
912 			comment = "Your user doesn't have privilege to perform this action";
913 			error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
914 			rc = ESLURM_ACCESS_DENIED;
915 			goto end_it;
916 		}
917 	}
918 
919 	rc = acct_storage_g_add_assocs(slurmdbd_conn->db_conn, *uid,
920 				       get_msg->my_list);
921 end_it:
922 	*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
923 						rc, comment, DBD_ADD_ASSOCS);
924 	return rc;
925 }
926 
_add_clusters(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)927 static int _add_clusters(slurmdbd_conn_t *slurmdbd_conn,
928 			 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
929 {
930 	int rc = SLURM_SUCCESS;
931 	dbd_list_msg_t *get_msg = msg->data;
932 	char *comment = NULL;
933 
934 	debug2("DBD_ADD_CLUSTERS: called");
935 
936 	rc = acct_storage_g_add_clusters(slurmdbd_conn->db_conn, *uid,
937 					 get_msg->my_list);
938 	if (rc == ESLURM_ACCESS_DENIED)
939 		comment = "Your user doesn't have privilege to perform this action";
940 	else if (rc != SLURM_SUCCESS)
941 		comment = "Failed to add cluster.";
942 
943 	*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
944 						rc, comment, DBD_ADD_CLUSTERS);
945 	return rc;
946 }
947 
_add_federations(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)948 static int _add_federations(slurmdbd_conn_t *slurmdbd_conn, persist_msg_t *msg,
949 			    Buf *out_buffer, uint32_t *uid)
950 {
951 	int rc = SLURM_SUCCESS;
952 	dbd_list_msg_t *get_msg = msg->data;
953 	char *comment = NULL;
954 
955 	debug2("DBD_ADD_FEDERATIONS: called");
956 
957 	rc = acct_storage_g_add_federations(slurmdbd_conn->db_conn, *uid,
958 					    get_msg->my_list);
959 	if (rc == ESLURM_ACCESS_DENIED)
960 		comment = "Your user doesn't have privilege to perform this "
961 			"action";
962 	else if (rc != SLURM_SUCCESS)
963 		comment = "Failed to add cluster.";
964 
965 	*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
966 						rc, comment,
967 						DBD_ADD_FEDERATIONS);
968 	return rc;
969 }
970 
_add_qos(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)971 static int _add_qos(slurmdbd_conn_t *slurmdbd_conn,
972 		    persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
973 {
974 	int rc = SLURM_SUCCESS;
975 	dbd_list_msg_t *get_msg = msg->data;
976 	char *comment = NULL;
977 
978 	debug2("DBD_ADD_QOS: called");
979 
980 	rc = acct_storage_g_add_qos(slurmdbd_conn->db_conn, *uid,
981 				    get_msg->my_list);
982 	if (rc == ESLURM_ACCESS_DENIED)
983 		comment = "Your user doesn't have privilege to perform this action";
984 	else if (rc != SLURM_SUCCESS)
985 		comment = "Failed to add qos.";
986 
987 	*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
988 						rc, comment, DBD_ADD_QOS);
989 	return rc;
990 }
991 
_add_res(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)992 static int _add_res(slurmdbd_conn_t *slurmdbd_conn,
993 		    persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
994 {
995 	int rc = SLURM_SUCCESS;
996 	dbd_list_msg_t *get_msg = msg->data;
997 	char *comment = NULL;
998 
999 	debug2("DBD_ADD_RES: called");
1000 
1001 	rc = acct_storage_g_add_res(slurmdbd_conn->db_conn, *uid,
1002 				    get_msg->my_list);
1003 	if (rc == ESLURM_ACCESS_DENIED)
1004 		comment = "Your user doesn't have privilege to perform this action";
1005 	else if (rc != SLURM_SUCCESS)
1006 		comment = "Failed to add system resource.";
1007 
1008 	*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1009 						rc, comment, DBD_ADD_RES);
1010 	return rc;
1011 }
1012 
_add_users(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1013 static int _add_users(slurmdbd_conn_t *slurmdbd_conn,
1014 		      persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1015 {
1016 	int rc = SLURM_SUCCESS;
1017 	dbd_list_msg_t *get_msg = msg->data;
1018 	char *comment = NULL;
1019 	debug2("DBD_ADD_USERS: called");
1020 
1021 	rc = acct_storage_g_add_users(slurmdbd_conn->db_conn, *uid,
1022 				      get_msg->my_list);
1023 
1024 	if (rc == ESLURM_ACCESS_DENIED)
1025 		comment = "Your user doesn't have privilege to perform this action";
1026 
1027 	*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1028 						rc, comment, DBD_ADD_USERS);
1029 	return rc;
1030 }
1031 
_add_wckeys(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1032 static int _add_wckeys(slurmdbd_conn_t *slurmdbd_conn,
1033 		       persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1034 {
1035 	int rc = SLURM_SUCCESS;
1036 	dbd_list_msg_t *get_msg = msg->data;
1037 	char *comment = NULL;
1038 
1039 	debug2("DBD_ADD_WCKEYS: called");
1040 
1041 	rc = acct_storage_g_add_wckeys(slurmdbd_conn->db_conn, *uid,
1042 				       get_msg->my_list);
1043 
1044 	*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1045 						rc, comment, DBD_ADD_WCKEYS);
1046 	return rc;
1047 }
1048 
_add_reservation(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1049 static int _add_reservation(slurmdbd_conn_t *slurmdbd_conn,
1050 			    persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1051 {
1052 	int rc = SLURM_SUCCESS;
1053 	dbd_rec_msg_t *rec_msg = msg->data;
1054 	char *comment = NULL;
1055 
1056 	if (!_validate_slurm_user(*uid)) {
1057 		comment = "DBD_ADD_RESV message from invalid uid";
1058 		error("DBD_ADD_RESV message from invalid uid %u", *uid);
1059 		rc = ESLURM_ACCESS_DENIED;
1060 		goto end_it;
1061 	}
1062 
1063 	debug2("DBD_ADD_RESV: called");
1064 
1065 	rc = acct_storage_g_add_reservation(slurmdbd_conn->db_conn,
1066 					    rec_msg->rec);
1067 
1068 end_it:
1069 	*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1070 						rc, comment, DBD_ADD_RESV);
1071 	return rc;
1072 }
1073 
_archive_dump(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1074 static int _archive_dump(slurmdbd_conn_t *slurmdbd_conn,
1075 			 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1076 {
1077 	int rc = SLURM_SUCCESS;
1078 	dbd_cond_msg_t *get_msg = msg->data;
1079 	char *comment = "SUCCESS";
1080 	slurmdb_archive_cond_t *arch_cond = NULL;
1081 
1082 	debug2("DBD_ARCHIVE_DUMP: called");
1083 	if (!_validate_super_user(*uid, slurmdbd_conn)) {
1084 		comment = "Your user doesn't have privilege to perform this action";
1085 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
1086 		rc = ESLURM_ACCESS_DENIED;
1087 		goto end_it;
1088 	}
1089 
1090 	arch_cond = (slurmdb_archive_cond_t *)get_msg->cond;
1091 	/* set up some defaults */
1092 	if (!arch_cond->archive_dir)
1093 		arch_cond->archive_dir = xstrdup(slurmdbd_conf->archive_dir);
1094 	if (!arch_cond->archive_script)
1095 		arch_cond->archive_script =
1096 			xstrdup(slurmdbd_conf->archive_script);
1097 
1098 	if (arch_cond->purge_event == NO_VAL)
1099 		arch_cond->purge_event = slurmdbd_conf->purge_event;
1100 	if (arch_cond->purge_job == NO_VAL)
1101 		arch_cond->purge_job = slurmdbd_conf->purge_job;
1102 	if (arch_cond->purge_resv == NO_VAL)
1103 		arch_cond->purge_resv = slurmdbd_conf->purge_resv;
1104 	if (arch_cond->purge_step == NO_VAL)
1105 		arch_cond->purge_step = slurmdbd_conf->purge_step;
1106 	if (arch_cond->purge_suspend == NO_VAL)
1107 		arch_cond->purge_suspend = slurmdbd_conf->purge_suspend;
1108 	if (arch_cond->purge_txn == NO_VAL)
1109 		arch_cond->purge_txn = slurmdbd_conf->purge_txn;
1110 	if (arch_cond->purge_usage == NO_VAL)
1111 		arch_cond->purge_usage = slurmdbd_conf->purge_usage;
1112 
1113 	rc = jobacct_storage_g_archive(slurmdbd_conn->db_conn, arch_cond);
1114 	if (rc != SLURM_SUCCESS) {
1115 		if (errno == EACCES)
1116 			comment = "Problem accessing file.";
1117 		else
1118 			comment = "Error with request.";
1119 	}
1120 end_it:
1121 	*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1122 						rc, comment, DBD_ARCHIVE_DUMP);
1123 	return rc;
1124 }
1125 
_archive_load(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1126 static int _archive_load(slurmdbd_conn_t *slurmdbd_conn,
1127 			 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1128 {
1129 	int rc = SLURM_SUCCESS;
1130 	slurmdb_archive_rec_t *arch_rec = msg->data;
1131 	char *comment = "SUCCESS";
1132 
1133 	debug2("DBD_ARCHIVE_LOAD: called");
1134 	if (!_validate_super_user(*uid, slurmdbd_conn)) {
1135 		comment = "Your user doesn't have privilege to perform this action";
1136 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
1137 		rc = ESLURM_ACCESS_DENIED;
1138 		goto end_it;
1139 	}
1140 
1141 	rc = jobacct_storage_g_archive_load(slurmdbd_conn->db_conn, arch_rec);
1142 
1143 	if (rc == ENOENT)
1144 		comment = "No archive file given to recover.";
1145 	else if (rc != SLURM_SUCCESS)
1146 		comment = "Error with request.";
1147 
1148 end_it:
1149 	*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1150 						rc, comment, DBD_ARCHIVE_LOAD);
1151 	return rc;
1152 }
1153 
_cluster_tres(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1154 static int _cluster_tres(slurmdbd_conn_t *slurmdbd_conn,
1155 			 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1156 {
1157 	dbd_cluster_tres_msg_t *cluster_tres_msg = msg->data;
1158 	int rc = SLURM_SUCCESS;
1159 	char *comment = NULL;
1160 
1161 	if (!_validate_slurm_user(*uid)) {
1162 		comment = "DBD_CLUSTER_TRES message from invalid uid";
1163 		error("DBD_CLUSTER_TRES message from invalid uid %u", *uid);
1164 		rc = ESLURM_ACCESS_DENIED;
1165 		goto end_it;
1166 	}
1167 
1168 	debug2("DBD_CLUSTER_TRES: called for %s(%s)",
1169 	       slurmdbd_conn->conn->cluster_name,
1170 	       cluster_tres_msg->tres_str);
1171 
1172 	rc = clusteracct_storage_g_cluster_tres(
1173 		slurmdbd_conn->db_conn,
1174 		cluster_tres_msg->cluster_nodes,
1175 		cluster_tres_msg->tres_str,
1176 		cluster_tres_msg->event_time,
1177 		slurmdbd_conn->conn->version);
1178 	if (rc == ESLURM_ACCESS_DENIED) {
1179 		comment = "This cluster hasn't been added to accounting yet";
1180 		rc = SLURM_ERROR;
1181 	}
1182 end_it:
1183 	if (rc == SLURM_SUCCESS) {
1184 		xfree(slurmdbd_conn->tres_str);
1185 		slurmdbd_conn->tres_str = cluster_tres_msg->tres_str;
1186 		cluster_tres_msg->tres_str = NULL;
1187 	}
1188 	if (!slurmdbd_conn->conn->rem_port) {
1189 		debug3("DBD_CLUSTER_TRES: cluster not registered");
1190 		slurmdbd_conn->conn->rem_port =
1191 			clusteracct_storage_g_register_disconn_ctld(
1192 				slurmdbd_conn->db_conn,
1193 				slurmdbd_conn->conn->rem_host);
1194 
1195 		_add_registered_cluster(slurmdbd_conn);
1196 	}
1197 
1198 	*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1199 						rc, comment, DBD_CLUSTER_TRES);
1200 	return rc;
1201 }
1202 
_get_accounts(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1203 static int _get_accounts(slurmdbd_conn_t *slurmdbd_conn,
1204 			 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1205 {
1206 	dbd_cond_msg_t *get_msg = msg->data;
1207 	dbd_list_msg_t list_msg = { NULL };
1208 	int rc = SLURM_SUCCESS;
1209 
1210 	debug2("DBD_GET_ACCOUNTS: called");
1211 
1212 	list_msg.my_list = acct_storage_g_get_accounts(slurmdbd_conn->db_conn,
1213 						       *uid, get_msg->cond);
1214 
1215 	if (!errno) {
1216 		if (!list_msg.my_list)
1217 			list_msg.my_list = list_create(NULL);
1218 		*out_buffer = init_buf(1024);
1219 		pack16((uint16_t) DBD_GOT_ACCOUNTS, *out_buffer);
1220 		slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
1221 				       DBD_GOT_ACCOUNTS,
1222 				       *out_buffer);
1223 	} else {
1224 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1225 							errno,
1226 							slurm_strerror(errno),
1227 							DBD_GET_ACCOUNTS);
1228 		rc = SLURM_ERROR;
1229 	}
1230 
1231 	FREE_NULL_LIST(list_msg.my_list);
1232 
1233 	return rc;
1234 }
1235 
_get_tres(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1236 static int _get_tres(slurmdbd_conn_t *slurmdbd_conn,
1237 		     persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1238 {
1239 	dbd_cond_msg_t *get_msg = msg->data;
1240 	dbd_list_msg_t list_msg = { NULL };
1241 	int rc = SLURM_SUCCESS;
1242 
1243 	debug2("DBD_GET_TRES: called");
1244 
1245 	list_msg.my_list = acct_storage_g_get_tres(
1246 		slurmdbd_conn->db_conn, *uid, get_msg->cond);
1247 
1248 	if (!errno) {
1249 		if (!list_msg.my_list)
1250 			list_msg.my_list = list_create(NULL);
1251 		*out_buffer = init_buf(1024);
1252 		pack16((uint16_t) DBD_GOT_TRES, *out_buffer);
1253 		slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
1254 				       DBD_GOT_TRES, *out_buffer);
1255 	} else {
1256 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1257 							errno,
1258 							slurm_strerror(errno),
1259 							DBD_GET_TRES);
1260 		rc = SLURM_ERROR;
1261 	}
1262 
1263 	FREE_NULL_LIST(list_msg.my_list);
1264 
1265 	return rc;
1266 }
1267 
_get_assocs(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1268 static int _get_assocs(slurmdbd_conn_t *slurmdbd_conn,
1269 		       persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1270 {
1271 	dbd_cond_msg_t *get_msg = msg->data;
1272 	dbd_list_msg_t list_msg = { NULL };
1273 	int rc = SLURM_SUCCESS;
1274 
1275 	debug2("DBD_GET_ASSOCS: called");
1276 
1277 	list_msg.my_list = acct_storage_g_get_assocs(
1278 		slurmdbd_conn->db_conn, *uid, get_msg->cond);
1279 
1280 	if (!errno) {
1281 		if (!list_msg.my_list)
1282 			list_msg.my_list = list_create(NULL);
1283 		*out_buffer = init_buf(1024);
1284 		pack16((uint16_t) DBD_GOT_ASSOCS, *out_buffer);
1285 		slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
1286 				       DBD_GOT_ASSOCS, *out_buffer);
1287 	} else {
1288 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1289 							errno,
1290 							slurm_strerror(errno),
1291 							DBD_GET_ASSOCS);
1292 		rc = SLURM_ERROR;
1293 	}
1294 
1295 	FREE_NULL_LIST(list_msg.my_list);
1296 
1297 	return rc;
1298 }
1299 
_get_clusters(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1300 static int _get_clusters(slurmdbd_conn_t *slurmdbd_conn,
1301 			 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1302 {
1303 	dbd_cond_msg_t *get_msg = msg->data;
1304 	dbd_list_msg_t list_msg = { NULL };
1305 	int rc = SLURM_SUCCESS;
1306 
1307 	debug2("DBD_GET_CLUSTERS: called");
1308 
1309 	list_msg.my_list = acct_storage_g_get_clusters(
1310 		slurmdbd_conn->db_conn, *uid, get_msg->cond);
1311 
1312 	if (!errno) {
1313 		if (!list_msg.my_list)
1314 			list_msg.my_list = list_create(NULL);
1315 		*out_buffer = init_buf(1024);
1316 		pack16((uint16_t) DBD_GOT_CLUSTERS, *out_buffer);
1317 		slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
1318 				       DBD_GOT_CLUSTERS,
1319 				       *out_buffer);
1320 	} else {
1321 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1322 							errno,
1323 							slurm_strerror(errno),
1324 							DBD_GET_CLUSTERS);
1325 		rc = SLURM_ERROR;
1326 	}
1327 
1328 	FREE_NULL_LIST(list_msg.my_list);
1329 
1330 	return rc;
1331 }
1332 
_get_federations(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1333 static int _get_federations(slurmdbd_conn_t *slurmdbd_conn, persist_msg_t *msg,
1334 			    Buf *out_buffer, uint32_t *uid)
1335 {
1336 	dbd_cond_msg_t *get_msg = msg->data;
1337 	dbd_list_msg_t list_msg = { NULL };
1338 	int rc = SLURM_SUCCESS;
1339 
1340 	debug2("DBD_GET_FEDERATIONS: called");
1341 
1342 	list_msg.my_list = acct_storage_g_get_federations(
1343 		slurmdbd_conn->db_conn, *uid, get_msg->cond);
1344 
1345 	if (!errno) {
1346 		if (!list_msg.my_list)
1347 			list_msg.my_list = list_create(NULL);
1348 		*out_buffer = init_buf(1024);
1349 		pack16((uint16_t) DBD_GOT_FEDERATIONS, *out_buffer);
1350 		slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
1351 				       DBD_GOT_FEDERATIONS,
1352 				       *out_buffer);
1353 	} else {
1354 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1355 							errno,
1356 							slurm_strerror(errno),
1357 							DBD_GET_FEDERATIONS);
1358 		rc = SLURM_ERROR;
1359 	}
1360 
1361 	FREE_NULL_LIST(list_msg.my_list);
1362 
1363 	return rc;
1364 }
1365 
_get_config(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1366 static int _get_config(slurmdbd_conn_t *slurmdbd_conn,
1367 		       persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1368 {
1369 	char *config_name = msg->data;
1370 	dbd_list_msg_t list_msg = { NULL };
1371 
1372 	debug2("DBD_GET_CONFIG: called");
1373 
1374 	if (config_name == NULL ||
1375 	    xstrcmp(config_name, "slurmdbd.conf") == 0)
1376 		list_msg.my_list = dump_config();
1377 	else if ((list_msg.my_list = acct_storage_g_get_config(
1378 			  slurmdbd_conn->db_conn, config_name)) == NULL) {
1379 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1380 							errno,
1381 							slurm_strerror(errno),
1382 							DBD_GET_CONFIG);
1383 		xfree(config_name);
1384 		return SLURM_ERROR;
1385 	}
1386 
1387 	*out_buffer = init_buf(1024);
1388 	pack16((uint16_t) DBD_GOT_CONFIG, *out_buffer);
1389 	slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
1390 			       DBD_GOT_CONFIG, *out_buffer);
1391 	FREE_NULL_LIST(list_msg.my_list);
1392 	xfree(config_name);
1393 
1394 	return SLURM_SUCCESS;
1395 }
1396 
_get_events(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1397 static int _get_events(slurmdbd_conn_t *slurmdbd_conn,
1398 		       persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1399 {
1400 	dbd_cond_msg_t *get_msg = msg->data;
1401 	dbd_list_msg_t list_msg = { NULL };
1402 	int rc = SLURM_SUCCESS;
1403 
1404 	debug2("DBD_GET_EVENTS: called");
1405 
1406 	list_msg.my_list = acct_storage_g_get_events(
1407 		slurmdbd_conn->db_conn, *uid, get_msg->cond);
1408 
1409 	if (!errno) {
1410 		if (!list_msg.my_list)
1411 			list_msg.my_list = list_create(NULL);
1412 		*out_buffer = init_buf(1024);
1413 		pack16((uint16_t) DBD_GOT_EVENTS, *out_buffer);
1414 		slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
1415 				       DBD_GOT_EVENTS,
1416 				       *out_buffer);
1417 	} else {
1418 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1419 							errno,
1420 							slurm_strerror(errno),
1421 							DBD_GET_EVENTS);
1422 		rc = SLURM_ERROR;
1423 	}
1424 
1425 	FREE_NULL_LIST(list_msg.my_list);
1426 
1427 	return rc;
1428 }
1429 
_get_jobs_cond(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1430 static int _get_jobs_cond(slurmdbd_conn_t *slurmdbd_conn,
1431 			  persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1432 {
1433 	dbd_cond_msg_t *cond_msg = msg->data;
1434 	dbd_list_msg_t list_msg = { NULL };
1435 	slurmdb_job_cond_t *job_cond = cond_msg->cond;
1436 	int rc = SLURM_SUCCESS;
1437 
1438 	debug2("DBD_GET_JOBS_COND: called");
1439 
1440 	/* fail early if requesting runaways and not super user */
1441 	if ((job_cond->flags & JOBCOND_FLAG_RUNAWAY) &&
1442 	    !_validate_operator(*uid, slurmdbd_conn)) {
1443 		debug("Rejecting query of runaways from uid %u", *uid);
1444 		*out_buffer = slurm_persist_make_rc_msg(
1445 			slurmdbd_conn->conn,
1446 			ESLURM_ACCESS_DENIED,
1447 			"You must have an AdminLevel>=Operator to fix runaway jobs",
1448 			DBD_GET_JOBS_COND);
1449 		return SLURM_ERROR;
1450 	}
1451 	/* fail early if too wide a query */
1452 	if (!job_cond->step_list && !_validate_operator(*uid, slurmdbd_conn)
1453 	    && (slurmdbd_conf->max_time_range != INFINITE)) {
1454 		time_t start, end;
1455 
1456 		start = job_cond->usage_start;
1457 
1458 		if (job_cond->usage_end)
1459 			end = job_cond->usage_end;
1460 		else
1461 			end = time(NULL);
1462 
1463 		if ((end - start) > slurmdbd_conf->max_time_range) {
1464 			info("Rejecting query > MaxQueryTimeRange from uid %u",
1465 			     *uid);
1466 			*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1467 								ESLURM_DB_QUERY_TOO_WIDE,
1468 								slurm_strerror(ESLURM_DB_QUERY_TOO_WIDE),
1469 								DBD_GET_JOBS_COND);
1470 			return SLURM_ERROR;
1471 		}
1472 	}
1473 
1474 	list_msg.my_list = jobacct_storage_g_get_jobs_cond(
1475 		slurmdbd_conn->db_conn, *uid, job_cond);
1476 
1477 	if (!errno) {
1478 		if (!list_msg.my_list)
1479 			list_msg.my_list = list_create(NULL);
1480 		*out_buffer = init_buf(1024);
1481 		pack16((uint16_t) DBD_GOT_JOBS, *out_buffer);
1482 		slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
1483 				       DBD_GOT_JOBS, *out_buffer);
1484 	} else {
1485 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1486 							errno,
1487 							slurm_strerror(errno),
1488 							DBD_GET_JOBS_COND);
1489 		rc = SLURM_ERROR;
1490 	}
1491 
1492 	FREE_NULL_LIST(list_msg.my_list);
1493 
1494 	return rc;
1495 }
1496 
_get_probs(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1497 static int _get_probs(slurmdbd_conn_t *slurmdbd_conn,
1498 		      persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1499 {
1500 	dbd_cond_msg_t *get_msg = msg->data;
1501 	dbd_list_msg_t list_msg = { NULL };
1502 	int rc = SLURM_SUCCESS;
1503 
1504 	debug2("DBD_GET_PROBS: called");
1505 
1506 	list_msg.my_list = acct_storage_g_get_problems(
1507 		slurmdbd_conn->db_conn, *uid, get_msg->cond);
1508 
1509 	if (!errno) {
1510 		if (!list_msg.my_list)
1511 			list_msg.my_list = list_create(NULL);
1512 		*out_buffer = init_buf(1024);
1513 		pack16((uint16_t) DBD_GOT_PROBS, *out_buffer);
1514 		slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
1515 				       DBD_GOT_PROBS, *out_buffer);
1516 	} else {
1517 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1518 							errno,
1519 							slurm_strerror(errno),
1520 							DBD_GET_PROBS);
1521 		rc = SLURM_ERROR;
1522 	}
1523 
1524 	FREE_NULL_LIST(list_msg.my_list);
1525 
1526 	return rc;
1527 }
1528 
_get_qos(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1529 static int _get_qos(slurmdbd_conn_t *slurmdbd_conn,
1530 		    persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1531 {
1532 	dbd_cond_msg_t *cond_msg = msg->data;
1533 	dbd_list_msg_t list_msg = { NULL };
1534 	int rc = SLURM_SUCCESS;
1535 
1536 	debug2("DBD_GET_QOS: called");
1537 
1538 	list_msg.my_list = acct_storage_g_get_qos(slurmdbd_conn->db_conn, *uid,
1539 						  cond_msg->cond);
1540 
1541 	if (errno == ESLURM_ACCESS_DENIED && !list_msg.my_list)
1542 		list_msg.my_list = list_create(NULL);
1543 
1544 	if (!errno) {
1545 		if (!list_msg.my_list)
1546 			list_msg.my_list = list_create(NULL);
1547 		*out_buffer = init_buf(1024);
1548 		pack16((uint16_t) DBD_GOT_QOS, *out_buffer);
1549 		slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
1550 				       DBD_GOT_QOS, *out_buffer);
1551 	} else {
1552 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1553 							errno,
1554 							slurm_strerror(errno),
1555 							DBD_GET_QOS);
1556 		rc = SLURM_ERROR;
1557 	}
1558 
1559 	FREE_NULL_LIST(list_msg.my_list);
1560 
1561 	return rc;
1562 }
1563 
_get_res(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1564 static int _get_res(slurmdbd_conn_t *slurmdbd_conn,
1565 		    persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1566 {
1567 	dbd_cond_msg_t *get_msg = msg->data;
1568 	dbd_list_msg_t list_msg = { NULL };
1569 	int rc = SLURM_SUCCESS;
1570 
1571 	debug2("DBD_GET_RES: called");
1572 
1573 	list_msg.my_list = acct_storage_g_get_res(
1574 		slurmdbd_conn->db_conn, *uid, get_msg->cond);
1575 
1576 	if (!errno) {
1577 		if (!list_msg.my_list)
1578 			list_msg.my_list = list_create(NULL);
1579 		*out_buffer = init_buf(1024);
1580 		pack16((uint16_t) DBD_GOT_RES, *out_buffer);
1581 		slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
1582 				       DBD_GOT_RES,
1583 				       *out_buffer);
1584 	} else {
1585 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1586 							errno,
1587 							slurm_strerror(errno),
1588 							DBD_GET_RES);
1589 		rc = SLURM_ERROR;
1590 	}
1591 
1592 	FREE_NULL_LIST(list_msg.my_list);
1593 	return rc;
1594 }
1595 
_get_txn(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1596 static int _get_txn(slurmdbd_conn_t *slurmdbd_conn,
1597 		    persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1598 {
1599 	dbd_cond_msg_t *cond_msg = msg->data;
1600 	dbd_list_msg_t list_msg = { NULL };
1601 	int rc = SLURM_SUCCESS;
1602 
1603 	debug2("DBD_GET_TXN: called");
1604 
1605 	list_msg.my_list = acct_storage_g_get_txn(slurmdbd_conn->db_conn, *uid,
1606 						  cond_msg->cond);
1607 
1608 	if (!errno) {
1609 		if (!list_msg.my_list)
1610 			list_msg.my_list = list_create(NULL);
1611 		*out_buffer = init_buf(1024);
1612 		pack16((uint16_t) DBD_GOT_TXN, *out_buffer);
1613 		slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
1614 				       DBD_GOT_TXN, *out_buffer);
1615 	} else {
1616 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1617 							errno,
1618 							slurm_strerror(errno),
1619 							DBD_GET_TXN);
1620 		rc = SLURM_ERROR;
1621 	}
1622 
1623 	FREE_NULL_LIST(list_msg.my_list);
1624 
1625 	return rc;
1626 }
1627 
_get_usage(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1628 static int _get_usage(slurmdbd_conn_t *slurmdbd_conn,
1629 		      persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1630 {
1631 	dbd_usage_msg_t *get_msg = msg->data;
1632 	dbd_usage_msg_t got_msg;
1633 	uint16_t ret_type = 0;
1634 	int rc = SLURM_SUCCESS;
1635 	char *comment = NULL;
1636 
1637 	info("DBD_GET_USAGE: called type is %s",
1638 	     slurmdbd_msg_type_2_str(msg->msg_type, 1));
1639 
1640 	switch(msg->msg_type) {
1641 	case DBD_GET_ASSOC_USAGE:
1642 		ret_type = DBD_GOT_ASSOC_USAGE;
1643 		break;
1644 	case DBD_GET_WCKEY_USAGE:
1645 		ret_type = DBD_GOT_WCKEY_USAGE;
1646 		break;
1647 	case DBD_GET_CLUSTER_USAGE:
1648 		ret_type = DBD_GOT_CLUSTER_USAGE;
1649 		break;
1650 	default:
1651 		comment = "Unknown type of usage to get";
1652 		error("%s %u", comment, msg->msg_type);
1653 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1654 							SLURM_ERROR, comment,
1655 							msg->msg_type);
1656 		return SLURM_ERROR;
1657 	}
1658 
1659 	rc = acct_storage_g_get_usage(slurmdbd_conn->db_conn,
1660 				      *uid, get_msg->rec, msg->msg_type,
1661 				      get_msg->start, get_msg->end);
1662 
1663 	if (rc != SLURM_SUCCESS) {
1664 		comment = "Problem getting usage info";
1665 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
1666 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1667 							rc, comment,
1668 							msg->msg_type);
1669 		return rc;
1670 
1671 	}
1672 	memset(&got_msg, 0, sizeof(dbd_usage_msg_t));
1673 	got_msg.rec = get_msg->rec;
1674 	get_msg->rec = NULL;
1675 	*out_buffer = init_buf(1024);
1676 	pack16((uint16_t) ret_type, *out_buffer);
1677 	slurmdbd_pack_usage_msg(&got_msg, slurmdbd_conn->conn->version,
1678 				ret_type, *out_buffer);
1679 
1680 	return SLURM_SUCCESS;
1681 }
1682 
_get_users(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1683 static int _get_users(slurmdbd_conn_t *slurmdbd_conn,
1684 		      persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1685 {
1686 	dbd_cond_msg_t *get_msg = msg->data;
1687 	dbd_list_msg_t list_msg = { NULL };
1688 	int rc = SLURM_SUCCESS;
1689 	slurmdb_user_cond_t * user_cond = NULL;
1690 
1691 	debug2("DBD_GET_USERS: called");
1692 
1693 	user_cond = get_msg->cond;
1694 	if ((!user_cond->with_assocs && !user_cond->with_wckeys)
1695 	    && ((slurmdbd_conn->conn->version < 8)
1696 		|| (user_cond->assoc_cond->only_defs))) {
1697 		List cluster_list = user_cond->assoc_cond->cluster_list;
1698 		/* load up with just this cluster to query against
1699 		 * since befor 2.2 we had only 1 default account so
1700 		 * send the default for this cluster. */
1701 		if (!cluster_list) {
1702 			cluster_list = list_create(NULL);
1703 			list_append(cluster_list,
1704 				    slurmdbd_conn->conn->cluster_name);
1705 			user_cond->assoc_cond->cluster_list = cluster_list;
1706 		}
1707 	}
1708 
1709 	list_msg.my_list = acct_storage_g_get_users(slurmdbd_conn->db_conn,
1710 						    *uid, user_cond);
1711 
1712 	if (!errno) {
1713 		if (!list_msg.my_list)
1714 			list_msg.my_list = list_create(NULL);
1715 		*out_buffer = init_buf(1024);
1716 		pack16((uint16_t) DBD_GOT_USERS, *out_buffer);
1717 		slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
1718 				       DBD_GOT_USERS, *out_buffer);
1719 	} else {
1720 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1721 							errno,
1722 							slurm_strerror(errno),
1723 							DBD_GET_USERS);
1724 		rc = SLURM_ERROR;
1725 	}
1726 
1727 	FREE_NULL_LIST(list_msg.my_list);
1728 
1729 	return rc;
1730 }
1731 
_get_wckeys(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1732 static int _get_wckeys(slurmdbd_conn_t *slurmdbd_conn,
1733 		       persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1734 {
1735 	dbd_cond_msg_t *get_msg = msg->data;
1736 	dbd_list_msg_t list_msg = { NULL };
1737 	char *comment = NULL;
1738 	int rc = SLURM_SUCCESS;
1739 
1740 	debug2("DBD_GET_WCKEYS: called");
1741 
1742 	/* We have to check this here, and not in the plugin.  There
1743 	 * are places in the plugin that a non-admin can call this and
1744 	 * it be ok. */
1745 	if (!_validate_operator(*uid, slurmdbd_conn)) {
1746 		comment = "Your user doesn't have privilege to perform this action";
1747 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
1748 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1749 							ESLURM_ACCESS_DENIED,
1750 							comment,
1751 							DBD_GET_WCKEYS);
1752 		return ESLURM_ACCESS_DENIED;
1753 	}
1754 
1755 	list_msg.my_list = acct_storage_g_get_wckeys(slurmdbd_conn->db_conn,
1756 						     *uid, get_msg->cond);
1757 
1758 	if (!errno) {
1759 		if (!list_msg.my_list)
1760 			list_msg.my_list = list_create(NULL);
1761 		*out_buffer = init_buf(1024);
1762 		pack16((uint16_t) DBD_GOT_WCKEYS, *out_buffer);
1763 		slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
1764 				       DBD_GOT_WCKEYS, *out_buffer);
1765 	} else {
1766 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1767 							errno,
1768 							slurm_strerror(errno),
1769 							DBD_GET_WCKEYS);
1770 		rc = SLURM_ERROR;
1771 	}
1772 
1773 	FREE_NULL_LIST(list_msg.my_list);
1774 
1775 	return rc;
1776 }
1777 
_get_reservations(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1778 static int _get_reservations(slurmdbd_conn_t *slurmdbd_conn,
1779 			     persist_msg_t *msg, Buf *out_buffer,
1780 			     uint32_t *uid)
1781 {
1782 	dbd_cond_msg_t *get_msg = msg->data;
1783 	dbd_list_msg_t list_msg = { NULL };
1784 	int rc = SLURM_SUCCESS;
1785 
1786 	debug2("DBD_GET_RESVS: called");
1787 
1788 	list_msg.my_list = acct_storage_g_get_reservations(
1789 		slurmdbd_conn->db_conn, *uid, get_msg->cond);
1790 
1791 	if (!errno) {
1792 		if (!list_msg.my_list)
1793 			list_msg.my_list = list_create(NULL);
1794 		*out_buffer = init_buf(1024);
1795 		pack16((uint16_t) DBD_GOT_RESVS, *out_buffer);
1796 		slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
1797 				       DBD_GOT_RESVS, *out_buffer);
1798 	} else {
1799 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1800 							errno,
1801 							slurm_strerror(errno),
1802 							DBD_GET_RESVS);
1803 		rc = SLURM_ERROR;
1804 	}
1805 
1806 	FREE_NULL_LIST(list_msg.my_list);
1807 
1808 	return rc;
1809 }
1810 
_find_rpc_obj_in_list(void * x,void * key)1811 static int _find_rpc_obj_in_list(void *x, void *key)
1812 {
1813 	slurmdb_rpc_obj_t *obj = (slurmdb_rpc_obj_t *)x;
1814 
1815 	if (obj->id == *(int *)key)
1816 		return 1;
1817 	return 0;
1818 }
1819 
_flush_jobs(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1820 static int _flush_jobs(slurmdbd_conn_t *slurmdbd_conn,
1821 		       persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1822 {
1823 	dbd_cluster_tres_msg_t *cluster_tres_msg = msg->data;
1824 	int rc = SLURM_SUCCESS;
1825 	char *comment = NULL;
1826 
1827 	if (!_validate_slurm_user(*uid)) {
1828 		comment = "DBD_FLUSH_JOBS message from invalid uid";
1829 		error("DBD_FLUSH_JOBS message from invalid uid %u", *uid);
1830 		rc = ESLURM_ACCESS_DENIED;
1831 		goto end_it;
1832 	}
1833 
1834 	debug2("DBD_FLUSH_JOBS: called for %s",
1835 	       slurmdbd_conn->conn->cluster_name);
1836 
1837 	rc = acct_storage_g_flush_jobs_on_cluster(
1838 		slurmdbd_conn->db_conn,
1839 		cluster_tres_msg->event_time);
1840 end_it:
1841 	*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1842 						rc, comment, DBD_FLUSH_JOBS);
1843 	return rc;
1844 }
1845 
_fini_conn(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer)1846 static int   _fini_conn(slurmdbd_conn_t *slurmdbd_conn, persist_msg_t *msg,
1847 			Buf *out_buffer)
1848 {
1849 	dbd_fini_msg_t *fini_msg = msg->data;
1850 	char *comment = NULL;
1851 	int rc = SLURM_SUCCESS;
1852 	bool locked = false;
1853 
1854 
1855 	debug2("DBD_FINI: CLOSE:%u COMMIT:%u",
1856 	       fini_msg->close_conn, fini_msg->commit);
1857 
1858 	if (slurmdbd_conn->conn->rem_port && slurmdbd_conf->commit_delay) {
1859 		slurm_mutex_lock(&registered_lock);
1860 		locked = true;
1861 	}
1862 
1863 	if (fini_msg->close_conn == 1)
1864 		rc = acct_storage_g_close_connection(&slurmdbd_conn->db_conn);
1865 	else
1866 		rc = acct_storage_g_commit(slurmdbd_conn->db_conn,
1867 					   fini_msg->commit);
1868 	if (locked)
1869 		slurm_mutex_unlock(&registered_lock);
1870 
1871 	*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1872 						rc, comment, DBD_FINI);
1873 	return rc;
1874 
1875 }
1876 
_job_complete(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1877 static int  _job_complete(slurmdbd_conn_t *slurmdbd_conn,
1878 			  persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1879 {
1880 	dbd_job_comp_msg_t *job_comp_msg = msg->data;
1881 	job_record_t job;
1882 	struct job_details details;
1883 	int rc = SLURM_SUCCESS;
1884 	char *comment = NULL;
1885 
1886 	if (!_validate_slurm_user(*uid)) {
1887 		comment = "DBD_JOB_COMPLETE message from invalid uid";
1888 		error("CONN:%u %s %u",
1889 		      slurmdbd_conn->conn->fd, comment, *uid);
1890 		rc = ESLURM_ACCESS_DENIED;
1891 		goto end_it;
1892 	}
1893 
1894 	memset(&job, 0, sizeof(job_record_t));
1895 	memset(&details, 0, sizeof(struct job_details));
1896 
1897 	job.admin_comment = job_comp_msg->admin_comment;
1898 	job.assoc_id = job_comp_msg->assoc_id;
1899 	job.comment = job_comp_msg->comment;
1900 	if (job_comp_msg->db_index != NO_VAL64)
1901 		job.db_index = job_comp_msg->db_index;
1902 	job.derived_ec = job_comp_msg->derived_ec;
1903 	job.end_time = job_comp_msg->end_time;
1904 	job.exit_code = job_comp_msg->exit_code;
1905 	job.job_id = job_comp_msg->job_id;
1906 	job.job_state = job_comp_msg->job_state;
1907 	job.requid = job_comp_msg->req_uid;
1908 	job.nodes = job_comp_msg->nodes;
1909 	job.start_time = job_comp_msg->start_time;
1910 	details.submit_time = job_comp_msg->submit_time;
1911 	job.start_protocol_ver = slurmdbd_conn->conn->version;
1912 	job.system_comment = job_comp_msg->system_comment;
1913 	job.tres_alloc_str = job_comp_msg->tres_alloc_str;
1914 
1915 	job.details = &details;
1916 
1917 	if (job.job_state & JOB_RESIZING) {
1918 		job.resize_time = job_comp_msg->end_time;
1919 		debug2("DBD_JOB_COMPLETE: RESIZE ID:%u", job_comp_msg->job_id);
1920 	} else
1921 		debug2("DBD_JOB_COMPLETE: ID:%u", job_comp_msg->job_id);
1922 
1923 	rc = jobacct_storage_g_job_complete(slurmdbd_conn->db_conn, &job);
1924 
1925 	if (rc && errno == 740) /* meaning data is already there */
1926 		rc = SLURM_SUCCESS;
1927 
1928 	/* just in case this gets set we need to clear it */
1929 	xfree(job.wckey);
1930 
1931 	if (!slurmdbd_conn->conn->rem_port) {
1932 		debug3("DBD_JOB_COMPLETE: cluster not registered");
1933 		slurmdbd_conn->conn->rem_port =
1934 			clusteracct_storage_g_register_disconn_ctld(
1935 				slurmdbd_conn->db_conn,
1936 				slurmdbd_conn->conn->rem_host);
1937 
1938 		_add_registered_cluster(slurmdbd_conn);
1939 	}
1940 
1941 end_it:
1942 	*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1943 						rc, comment, DBD_JOB_COMPLETE);
1944 	return SLURM_SUCCESS;
1945 }
1946 
_job_start(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1947 static int  _job_start(slurmdbd_conn_t *slurmdbd_conn,
1948 		       persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1949 {
1950 	dbd_job_start_msg_t *job_start_msg = msg->data;
1951 	dbd_id_rc_msg_t id_rc_msg;
1952 	char *comment = NULL;
1953 
1954 	if (!_validate_slurm_user(*uid)) {
1955 		comment = "DBD_JOB_START message from invalid uid";
1956 		error("CONN:%u %s %u",
1957 		      slurmdbd_conn->conn->fd, comment, *uid);
1958 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
1959 							ESLURM_ACCESS_DENIED,
1960 							comment,
1961 							DBD_JOB_START);
1962 		return SLURM_ERROR;
1963 	}
1964 
1965 	_process_job_start(slurmdbd_conn, job_start_msg, &id_rc_msg);
1966 
1967 	*out_buffer = init_buf(1024);
1968 	pack16((uint16_t) DBD_ID_RC, *out_buffer);
1969 	slurmdbd_pack_id_rc_msg(&id_rc_msg,
1970 				slurmdbd_conn->conn->version, *out_buffer);
1971 	return SLURM_SUCCESS;
1972 }
1973 
_job_suspend(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)1974 static int  _job_suspend(slurmdbd_conn_t *slurmdbd_conn,
1975 			 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
1976 {
1977 	dbd_job_suspend_msg_t *job_suspend_msg = msg->data;
1978 	job_record_t job;
1979 	struct job_details details;
1980 	int rc = SLURM_SUCCESS;
1981 	char *comment = NULL;
1982 
1983 	if (!_validate_slurm_user(*uid)) {
1984 		comment = "DBD_JOB_SUSPEND message from invalid uid";
1985 		error("CONN:%u %s %u",
1986 		      slurmdbd_conn->conn->fd, comment, *uid);
1987 		rc = ESLURM_ACCESS_DENIED;
1988 		goto end_it;
1989 	}
1990 
1991 	debug2("DBD_JOB_SUSPEND: ID:%u STATE:%s",
1992 	       job_suspend_msg->job_id,
1993 	       job_state_string(job_suspend_msg->job_state));
1994 
1995 	memset(&job, 0, sizeof(job_record_t));
1996 	memset(&details, 0, sizeof(struct job_details));
1997 
1998 	job.assoc_id = job_suspend_msg->assoc_id;
1999 	if (job_suspend_msg->db_index != NO_VAL64)
2000 		job.db_index = job_suspend_msg->db_index;
2001 	job.job_id = job_suspend_msg->job_id;
2002 	job.job_state = job_suspend_msg->job_state;
2003 	details.submit_time = job_suspend_msg->submit_time;
2004 	job.start_protocol_ver = slurmdbd_conn->conn->version;
2005 	job.suspend_time = job_suspend_msg->suspend_time;
2006 
2007 	job.details = &details;
2008 	rc = jobacct_storage_g_job_suspend(slurmdbd_conn->db_conn, &job);
2009 
2010 	if (rc && errno == 740) /* meaning data is already there */
2011 		rc = SLURM_SUCCESS;
2012 
2013 	/* just in case this gets set we need to clear it */
2014 	xfree(job.wckey);
2015 end_it:
2016 	*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
2017 						rc, comment,
2018 						DBD_JOB_SUSPEND);
2019 	return SLURM_SUCCESS;
2020 }
2021 
_modify_accounts(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2022 static int   _modify_accounts(slurmdbd_conn_t *slurmdbd_conn,
2023 			      persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
2024 {
2025 	dbd_list_msg_t list_msg = { NULL };
2026 	int rc = SLURM_SUCCESS;
2027 	dbd_modify_msg_t *get_msg = msg->data;
2028 	char *comment = NULL;
2029 
2030 	debug2("DBD_MODIFY_ACCOUNTS: called");
2031 
2032 	if (!(list_msg.my_list = acct_storage_g_modify_accounts(
2033 		      slurmdbd_conn->db_conn, *uid, get_msg->cond,
2034 		      get_msg->rec))) {
2035 		if (errno == ESLURM_ACCESS_DENIED) {
2036 			comment = "Your user doesn't have privilege to perform this action";
2037 			rc = ESLURM_ACCESS_DENIED;
2038 		} else if (errno == SLURM_ERROR) {
2039 			comment = "Something was wrong with your query";
2040 			rc = SLURM_ERROR;
2041 		} else if (errno == SLURM_NO_CHANGE_IN_DATA) {
2042 			comment = "Request didn't affect anything";
2043 			rc = SLURM_SUCCESS;
2044 		} else if (errno == ESLURM_DB_CONNECTION) {
2045 			comment = slurm_strerror(errno);
2046 			rc = errno;
2047 		} else {
2048 			rc = errno;
2049 			if (!(comment = slurm_strerror(errno)))
2050 				comment = "Unknown issue";
2051 		}
2052 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2053 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
2054 							rc, comment,
2055 							DBD_MODIFY_ACCOUNTS);
2056 		return rc;
2057 	}
2058 
2059 	*out_buffer = init_buf(1024);
2060 	pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
2061 	slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
2062 			       DBD_GOT_LIST, *out_buffer);
2063 	FREE_NULL_LIST(list_msg.my_list);
2064 
2065 	return rc;
2066 }
2067 
_modify_assocs(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2068 static int   _modify_assocs(slurmdbd_conn_t *slurmdbd_conn,
2069 			    persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
2070 {
2071 	dbd_list_msg_t list_msg = { NULL };
2072 	int rc = SLURM_SUCCESS;
2073 	dbd_modify_msg_t *get_msg = msg->data;
2074 	char *comment = NULL;
2075 
2076 	debug2("DBD_MODIFY_ASSOCS: called");
2077 
2078 	/* All authentication needs to be done inside the plugin since we are
2079 	 * unable to know what accounts this request is talking about
2080 	 * until we process it through the database.
2081 	 */
2082 
2083 	if (!(list_msg.my_list = acct_storage_g_modify_assocs(
2084 		      slurmdbd_conn->db_conn, *uid, get_msg->cond,
2085 		      get_msg->rec))) {
2086 		if (errno == ESLURM_ACCESS_DENIED) {
2087 			comment = "Your user doesn't have privilege to perform this action";
2088 			rc = ESLURM_ACCESS_DENIED;
2089 		} else if (errno == SLURM_ERROR) {
2090 			comment = "Something was wrong with your query";
2091 			rc = SLURM_ERROR;
2092 		} else if (errno == SLURM_NO_CHANGE_IN_DATA) {
2093 			comment = "Request didn't affect anything";
2094 			rc = SLURM_SUCCESS;
2095 		} else if (errno == ESLURM_DB_CONNECTION) {
2096 			comment = slurm_strerror(errno);
2097 			rc = errno;
2098 		} else {
2099 			rc = errno;
2100 			if (!(comment = slurm_strerror(errno)))
2101 				comment = "Unknown issue";
2102 		}
2103 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2104 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
2105 							rc, comment,
2106 							DBD_MODIFY_ASSOCS);
2107 		return rc;
2108 	}
2109 
2110 	*out_buffer = init_buf(1024);
2111 	pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
2112 	slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
2113 			       DBD_GOT_LIST, *out_buffer);
2114 	FREE_NULL_LIST(list_msg.my_list);
2115 
2116 	return rc;
2117 }
2118 
_modify_clusters(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2119 static int   _modify_clusters(slurmdbd_conn_t *slurmdbd_conn,
2120 			      persist_msg_t *msg, Buf *out_buffer,
2121 			      uint32_t *uid)
2122 {
2123 	dbd_list_msg_t list_msg = { NULL };
2124 	int rc = SLURM_SUCCESS;
2125 	dbd_modify_msg_t *get_msg = msg->data;
2126 	char *comment = NULL;
2127 
2128 	debug2("DBD_MODIFY_CLUSTERS: called");
2129 
2130 	if (!(list_msg.my_list = acct_storage_g_modify_clusters(
2131 		      slurmdbd_conn->db_conn, *uid, get_msg->cond,
2132 		      get_msg->rec))) {
2133 		if (errno == ESLURM_ACCESS_DENIED) {
2134 			comment = "Your user doesn't have privilege to perform this action";
2135 			rc = ESLURM_ACCESS_DENIED;
2136 		} else if (errno == SLURM_ERROR) {
2137 			comment = "Something was wrong with your query";
2138 			rc = SLURM_ERROR;
2139 		} else if (errno == SLURM_NO_CHANGE_IN_DATA) {
2140 			comment = "Request didn't affect anything";
2141 			rc = SLURM_SUCCESS;
2142 		} else if (errno == ESLURM_DB_CONNECTION) {
2143 			comment = slurm_strerror(errno);
2144 			rc = errno;
2145 		} else {
2146 			rc = errno;
2147 			if (!(comment = slurm_strerror(errno)))
2148 				comment = "Unknown issue";
2149 		}
2150 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2151 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
2152 							rc, comment,
2153 							DBD_MODIFY_CLUSTERS);
2154 		return rc;
2155 	}
2156 
2157 	*out_buffer = init_buf(1024);
2158 	pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
2159 	slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
2160 			       DBD_GOT_LIST, *out_buffer);
2161 	FREE_NULL_LIST(list_msg.my_list);
2162 
2163 	return rc;
2164 }
2165 
_modify_federations(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2166 static int _modify_federations(slurmdbd_conn_t *slurmdbd_conn,
2167 			       persist_msg_t *msg,
2168 			       Buf *out_buffer, uint32_t *uid)
2169 {
2170 	dbd_list_msg_t list_msg = { NULL };
2171 	int rc = SLURM_SUCCESS;
2172 	dbd_modify_msg_t *get_msg = msg->data;
2173 	char *comment = NULL;
2174 
2175 	debug2("DBD_MODIFY_FEDERATIONS: called");
2176 
2177 	if (!(list_msg.my_list = acct_storage_g_modify_federations(
2178 		      slurmdbd_conn->db_conn, *uid, get_msg->cond,
2179 		      get_msg->rec))) {
2180 		if (errno == ESLURM_ACCESS_DENIED) {
2181 			comment = "Your user doesn't have privilege to perform "
2182 				"this action";
2183 			rc = ESLURM_ACCESS_DENIED;
2184 		} else if (errno == SLURM_ERROR) {
2185 			comment = "Something was wrong with your query";
2186 			rc = SLURM_ERROR;
2187 		} else if (errno == SLURM_NO_CHANGE_IN_DATA) {
2188 			comment = "Request didn't affect anything";
2189 			rc = SLURM_SUCCESS;
2190 		} else if (errno == ESLURM_DB_CONNECTION) {
2191 			comment = slurm_strerror(errno);
2192 			rc = errno;
2193 		} else {
2194 			rc = errno;
2195 			if (!(comment = slurm_strerror(errno)))
2196 				comment = "Unknown issue";
2197 		}
2198 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2199 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
2200 							rc, comment,
2201 							DBD_MODIFY_FEDERATIONS);
2202 		return rc;
2203 	}
2204 
2205 	*out_buffer = init_buf(1024);
2206 	pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
2207 	slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
2208 			       DBD_GOT_LIST, *out_buffer);
2209 	FREE_NULL_LIST(list_msg.my_list);
2210 
2211 	return rc;
2212 }
2213 
_modify_job(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2214 static int   _modify_job(slurmdbd_conn_t *slurmdbd_conn,
2215 			 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
2216 {
2217 	dbd_list_msg_t list_msg = { NULL };
2218 	int rc = SLURM_SUCCESS;
2219 	dbd_modify_msg_t *get_msg = msg->data;
2220 	char *comment = NULL;
2221 
2222 	debug2("DBD_MODIFY_JOB: called");
2223 
2224 	if (!(list_msg.my_list = acct_storage_g_modify_job(
2225 		      slurmdbd_conn->db_conn, *uid, get_msg->cond,
2226 		      get_msg->rec))) {
2227 		if (errno == ESLURM_ACCESS_DENIED) {
2228 			comment = "Your user doesn't have privilege to perform this action";
2229 			rc = ESLURM_ACCESS_DENIED;
2230 		} else if (errno == SLURM_ERROR) {
2231 			comment = "Something was wrong with your query";
2232 			rc = SLURM_ERROR;
2233 		} else if (errno == SLURM_NO_CHANGE_IN_DATA) {
2234 			comment = "Request didn't affect anything";
2235 			rc = SLURM_SUCCESS;
2236 		} else if (errno == ESLURM_DB_CONNECTION) {
2237 			comment = slurm_strerror(errno);
2238 			rc = errno;
2239 		} else {
2240 			rc = errno;
2241 			if (!(comment = slurm_strerror(errno)))
2242 				comment = "Unknown issue";
2243 		}
2244 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2245 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
2246 							rc, comment,
2247 							DBD_MODIFY_JOB);
2248 		return rc;
2249 	}
2250 
2251 	if (get_msg->cond &&
2252 	    (((slurmdb_job_cond_t *)get_msg->cond)->flags &
2253 	     JOBCOND_FLAG_NO_WAIT)) {
2254 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
2255 							rc, comment,
2256 							DBD_MODIFY_JOB);
2257 	} else {
2258 		*out_buffer = init_buf(1024);
2259 		pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
2260 		slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
2261 				       DBD_GOT_LIST, *out_buffer);
2262 	}
2263 
2264 	FREE_NULL_LIST(list_msg.my_list);
2265 
2266 	return rc;
2267 }
2268 
_modify_qos(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2269 static int   _modify_qos(slurmdbd_conn_t *slurmdbd_conn,
2270 			 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
2271 {
2272 	dbd_list_msg_t list_msg = { NULL };
2273 	int rc = SLURM_SUCCESS;
2274 	dbd_modify_msg_t *get_msg = msg->data;
2275 	char *comment = NULL;
2276 
2277 	debug2("DBD_MODIFY_QOS: called");
2278 
2279 	if (!(list_msg.my_list = acct_storage_g_modify_qos(
2280 		      slurmdbd_conn->db_conn, *uid, get_msg->cond,
2281 		      get_msg->rec))) {
2282 		if (errno == ESLURM_ACCESS_DENIED) {
2283 			comment = "Your user doesn't have privilege to perform this action";
2284 			rc = ESLURM_ACCESS_DENIED;
2285 		} else if (errno == SLURM_ERROR) {
2286 			comment = "Something was wrong with your query";
2287 			rc = SLURM_ERROR;
2288 		} else if (errno == SLURM_NO_CHANGE_IN_DATA) {
2289 			comment = "Request didn't affect anything";
2290 			rc = SLURM_SUCCESS;
2291 		} else if (errno == ESLURM_QOS_PREEMPTION_LOOP) {
2292 			comment = "QOS Preemption loop detected";
2293 			rc = ESLURM_QOS_PREEMPTION_LOOP;
2294 		} else if (errno == ESLURM_DB_CONNECTION) {
2295 			comment = slurm_strerror(errno);
2296 			rc = errno;
2297 		} else {
2298 			rc = errno;
2299 			if (!(comment = slurm_strerror(errno)))
2300 				comment = "Unknown issue";
2301 		}
2302 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2303 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
2304 							rc, comment,
2305 							DBD_MODIFY_QOS);
2306 		return rc;
2307 	}
2308 
2309 	*out_buffer = init_buf(1024);
2310 	pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
2311 	slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
2312 			       DBD_GOT_LIST, *out_buffer);
2313 	FREE_NULL_LIST(list_msg.my_list);
2314 
2315 	return rc;
2316 }
2317 
_modify_res(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2318 static int   _modify_res(slurmdbd_conn_t *slurmdbd_conn,
2319 			 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
2320 {
2321 	dbd_list_msg_t list_msg = { NULL };
2322 	int rc = SLURM_SUCCESS;
2323 	dbd_modify_msg_t *get_msg = msg->data;
2324 	char *comment = NULL;
2325 
2326 	debug2("DBD_MODIFY_RES: called");
2327 
2328 	if (!(list_msg.my_list = acct_storage_g_modify_res(
2329 		      slurmdbd_conn->db_conn, *uid, get_msg->cond,
2330 		      get_msg->rec))) {
2331 		if (errno == ESLURM_ACCESS_DENIED) {
2332 			comment = "Your user doesn't have privilege to perform "
2333 				"this action";
2334 			rc = ESLURM_ACCESS_DENIED;
2335 		} else if (errno == SLURM_ERROR) {
2336 			comment = "Something was wrong with your query";
2337 			rc = SLURM_ERROR;
2338 		} else if (errno == SLURM_NO_CHANGE_IN_DATA) {
2339 			comment = "Request didn't affect anything";
2340 			rc = SLURM_SUCCESS;
2341 		} else if (errno == ESLURM_DB_CONNECTION) {
2342 			comment = slurm_strerror(errno);
2343 			rc = errno;
2344 		} else {
2345 			rc = errno;
2346 			if (!(comment = slurm_strerror(errno)))
2347 				comment = "Unknown issue";
2348 		}
2349 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2350 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
2351 							rc, comment,
2352 							DBD_MODIFY_RES);
2353 		return rc;
2354 	}
2355 
2356 	*out_buffer = init_buf(1024);
2357 	pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
2358 	slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
2359 			       DBD_GOT_LIST, *out_buffer);
2360 	FREE_NULL_LIST(list_msg.my_list);
2361 	return rc;
2362 }
2363 
_modify_users(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2364 static int   _modify_users(slurmdbd_conn_t *slurmdbd_conn,
2365 			   persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
2366 {
2367 	dbd_list_msg_t list_msg = { NULL };
2368 	int rc = SLURM_SUCCESS;
2369 	dbd_modify_msg_t *get_msg = msg->data;
2370 	char *comment = NULL;
2371 	int same_user = 0;
2372 	slurmdb_user_cond_t *user_cond = NULL;
2373 	slurmdb_user_rec_t *user_rec = NULL;
2374 
2375 	debug2("DBD_MODIFY_USERS: called");
2376 
2377 	user_cond = (slurmdb_user_cond_t *)get_msg->cond;
2378 	user_rec = (slurmdb_user_rec_t *)get_msg->rec;
2379 
2380 	if (!_validate_operator(*uid, slurmdbd_conn)) {
2381 		if (user_cond && user_cond->assoc_cond
2382 		    && user_cond->assoc_cond->user_list
2383 		    && (list_count(user_cond->assoc_cond->user_list) == 1)) {
2384 			uid_t pw_uid;
2385 			char *name;
2386 			name = list_peek (user_cond->assoc_cond->user_list);
2387 		        if ((uid_from_string (name, &pw_uid) >= 0)
2388 			    && pw_uid == *uid) {
2389 				same_user = 1;
2390 				goto is_same_user;
2391 			}
2392 		}
2393 		comment = "Your user doesn't have privilege to perform this action";
2394 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2395 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
2396 							ESLURM_ACCESS_DENIED,
2397 							comment,
2398 							DBD_MODIFY_USERS);
2399 
2400 		return ESLURM_ACCESS_DENIED;
2401 	}
2402 
2403 is_same_user:
2404 
2405 	/* same_user can only alter the default account, default wckey
2406 	 * nothing else */
2407 	if (same_user) {
2408 		/* If we add anything else here for the user we will
2409 		 * need to document it
2410 		 */
2411 		if ((user_rec->admin_level != SLURMDB_ADMIN_NOTSET)) {
2412 			comment = "You can only change your own default account, default wckey nothing else";
2413 			error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2414 			*out_buffer = slurm_persist_make_rc_msg(
2415 				slurmdbd_conn->conn,
2416 				ESLURM_ACCESS_DENIED,
2417 				comment,
2418 				DBD_MODIFY_USERS);
2419 
2420 			return ESLURM_ACCESS_DENIED;
2421 		}
2422 	}
2423 
2424 	if ((user_rec->admin_level != SLURMDB_ADMIN_NOTSET) &&
2425 	    !_validate_super_user(*uid, slurmdbd_conn)) {
2426 		comment = "You must be a super user to modify a users admin level";
2427 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2428 		*out_buffer = slurm_persist_make_rc_msg(
2429 			slurmdbd_conn->conn,
2430 			ESLURM_ACCESS_DENIED,
2431 			comment,
2432 			DBD_MODIFY_USERS);
2433 		return ESLURM_ACCESS_DENIED;
2434 	}
2435 
2436 	if (!(list_msg.my_list = acct_storage_g_modify_users(
2437 		      slurmdbd_conn->db_conn, *uid, user_cond, user_rec))) {
2438 		if (errno == ESLURM_ACCESS_DENIED) {
2439 			comment = "Your user doesn't have privilege to perform this action";
2440 			rc = ESLURM_ACCESS_DENIED;
2441 		} else if (errno == SLURM_ERROR) {
2442 			comment = "Something was wrong with your query";
2443 			rc = SLURM_ERROR;
2444 		} else if (errno == SLURM_NO_CHANGE_IN_DATA) {
2445 			comment = "Request didn't affect anything";
2446 			rc = SLURM_SUCCESS;
2447 		} else if (errno == ESLURM_DB_CONNECTION) {
2448 			comment = slurm_strerror(errno);
2449 			rc = errno;
2450 		} else {
2451 			rc = errno;
2452 			if (!(comment = slurm_strerror(errno)))
2453 				comment = "Unknown issue";
2454 		}
2455 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2456 		*out_buffer = slurm_persist_make_rc_msg(
2457 			slurmdbd_conn->conn, rc, comment, DBD_MODIFY_USERS);
2458 		return rc;
2459 	}
2460 
2461 	*out_buffer = init_buf(1024);
2462 	pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
2463 	slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
2464 			       DBD_GOT_LIST, *out_buffer);
2465 	FREE_NULL_LIST(list_msg.my_list);
2466 
2467 	return rc;
2468 }
2469 
_modify_wckeys(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2470 static int   _modify_wckeys(slurmdbd_conn_t *slurmdbd_conn,
2471 			    persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
2472 {
2473 	dbd_list_msg_t list_msg = { NULL };
2474 	int rc = SLURM_SUCCESS;
2475 	dbd_modify_msg_t *get_msg = msg->data;
2476 	char *comment = NULL;
2477 
2478 	debug2("DBD_MODIFY_WCKEYS: called");
2479 
2480 	if (!(list_msg.my_list = acct_storage_g_modify_wckeys(
2481 		      slurmdbd_conn->db_conn, *uid, get_msg->cond,
2482 		      get_msg->rec))) {
2483 		if (errno == ESLURM_ACCESS_DENIED) {
2484 			comment = "Your user doesn't have privilege to perform this action";
2485 			rc = ESLURM_ACCESS_DENIED;
2486 		} else if (errno == SLURM_ERROR) {
2487 			comment = "Something was wrong with your query";
2488 			rc = SLURM_ERROR;
2489 		} else if (errno == SLURM_NO_CHANGE_IN_DATA) {
2490 			comment = "Request didn't affect anything";
2491 			rc = SLURM_SUCCESS;
2492 		} else if (errno == ESLURM_DB_CONNECTION) {
2493 			comment = slurm_strerror(errno);
2494 			rc = errno;
2495 		} else {
2496 			rc = errno;
2497 			if (!(comment = slurm_strerror(errno)))
2498 				comment = "Unknown issue";
2499 		}
2500 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2501 		*out_buffer = slurm_persist_make_rc_msg(
2502 			slurmdbd_conn->conn, rc, comment, DBD_MODIFY_WCKEYS);
2503 		return rc;
2504 	}
2505 
2506 	*out_buffer = init_buf(1024);
2507 	pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
2508 	slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
2509 			       DBD_GOT_LIST, *out_buffer);
2510 	FREE_NULL_LIST(list_msg.my_list);
2511 
2512 	return rc;
2513 }
2514 
_modify_reservation(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2515 static int _modify_reservation(slurmdbd_conn_t *slurmdbd_conn,
2516 			       persist_msg_t *msg, Buf *out_buffer,
2517 			       uint32_t *uid)
2518 {
2519 	int rc = SLURM_SUCCESS;
2520 	dbd_rec_msg_t *rec_msg = msg->data;
2521 	char *comment = NULL;
2522 
2523 	if (!_validate_slurm_user(*uid)) {
2524 		comment = "DBD_MODIFY_RESV message from invalid uid";
2525 		error("CONN:%u %s %u",
2526 		      slurmdbd_conn->conn->fd, comment, *uid);
2527 		rc = ESLURM_ACCESS_DENIED;
2528 		goto end_it;
2529 	}
2530 
2531 	debug2("DBD_MODIFY_RESV: called");
2532 
2533 	rc = acct_storage_g_modify_reservation(slurmdbd_conn->db_conn,
2534 					       rec_msg->rec);
2535 
2536 end_it:
2537 	*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
2538 						rc, comment, DBD_MODIFY_RESV);
2539 	return rc;
2540 }
2541 
_node_state(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2542 static int _node_state(slurmdbd_conn_t *slurmdbd_conn,
2543 		       persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
2544 {
2545 	dbd_node_state_msg_t *node_state_msg = msg->data;
2546 	node_record_t node_ptr;
2547 	int rc = SLURM_SUCCESS;
2548 	char *comment = NULL;
2549 
2550 	if (!_validate_slurm_user(*uid)) {
2551 		comment = "DBD_NODE_STATE message from invalid uid";
2552 		error("CONN:%u %s %u",
2553 		      slurmdbd_conn->conn->fd, comment, *uid);
2554 		rc = ESLURM_ACCESS_DENIED;
2555 		goto end_it;
2556 	}
2557 
2558 	memset(&node_ptr, 0, sizeof(node_record_t));
2559 	node_ptr.name = node_state_msg->hostlist;
2560 	node_ptr.tres_str = node_state_msg->tres_str;
2561 	node_ptr.node_state = node_state_msg->state;
2562 	node_ptr.reason = node_state_msg->reason;
2563 	node_ptr.reason_time = node_state_msg->event_time;
2564 	node_ptr.reason_uid = node_state_msg->reason_uid;
2565 
2566 	if (!node_ptr.tres_str)
2567 		node_state_msg->new_state = DBD_NODE_STATE_UP;
2568 
2569 	if (node_state_msg->new_state == DBD_NODE_STATE_UP) {
2570 		debug2("DBD_NODE_STATE_UP: NODE:%s REASON:%s TIME:%ld",
2571 		       node_state_msg->hostlist,
2572 		       node_state_msg->reason,
2573 		       (long)node_state_msg->event_time);
2574 
2575 		/* clusteracct_storage_g_node_up can change the reason
2576 		 * field so copy it to avoid memory issues.
2577 		 */
2578 		node_ptr.reason = xstrdup(node_state_msg->reason);
2579 		rc = clusteracct_storage_g_node_up(
2580 			slurmdbd_conn->db_conn,
2581 			&node_ptr,
2582 			node_state_msg->event_time);
2583 		xfree(node_ptr.reason);
2584 	} else {
2585 		debug2("DBD_NODE_STATE_DOWN: NODE:%s STATE:%s REASON:%s UID:%u TIME:%ld",
2586 		       node_state_msg->hostlist,
2587 		       node_state_string(node_state_msg->state),
2588 		       node_state_msg->reason,
2589 		       node_ptr.reason_uid,
2590 		       (long)node_state_msg->event_time);
2591 		rc = clusteracct_storage_g_node_down(
2592 			slurmdbd_conn->db_conn,
2593 			&node_ptr,
2594 			node_state_msg->event_time,
2595 			node_state_msg->reason, node_ptr.reason_uid);
2596 	}
2597 
2598 end_it:
2599 	*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
2600 						rc, comment, DBD_NODE_STATE);
2601 	return SLURM_SUCCESS;
2602 }
2603 
_process_job_start(slurmdbd_conn_t * slurmdbd_conn,dbd_job_start_msg_t * job_start_msg,dbd_id_rc_msg_t * id_rc_msg)2604 static void _process_job_start(slurmdbd_conn_t *slurmdbd_conn,
2605 			       dbd_job_start_msg_t *job_start_msg,
2606 			       dbd_id_rc_msg_t *id_rc_msg)
2607 {
2608 	job_record_t job, *job_ptr;
2609 	struct job_details details;
2610 	job_array_struct_t array_recs;
2611 
2612 	memset(&job, 0, sizeof(job_record_t));
2613 	memset(&details, 0, sizeof(struct job_details));
2614 	memset(&array_recs, 0, sizeof(job_array_struct_t));
2615 	memset(id_rc_msg, 0, sizeof(dbd_id_rc_msg_t));
2616 
2617 	job.total_nodes = job_start_msg->alloc_nodes;
2618 	job.account = _replace_double_quotes(job_start_msg->account);
2619 	job.array_job_id = job_start_msg->array_job_id;
2620 	job.array_task_id = job_start_msg->array_task_id;
2621 	array_recs.task_id_str = job_start_msg->array_task_str;
2622 	array_recs.max_run_tasks = job_start_msg->array_max_tasks;
2623 	array_recs.task_cnt = job_start_msg->array_task_pending;
2624 	job.assoc_id = job_start_msg->assoc_id;
2625 	if (job_start_msg->db_index != NO_VAL64)
2626 		job.db_index = job_start_msg->db_index;
2627 	details.begin_time = job_start_msg->eligible_time;
2628 	job.user_id = job_start_msg->uid;
2629 	job.group_id = job_start_msg->gid;
2630 	job.het_job_id = job_start_msg->het_job_id;
2631 	job.het_job_offset = job_start_msg->het_job_offset;
2632 	job.job_id = job_start_msg->job_id;
2633 	job.job_state = job_start_msg->job_state;
2634 	job.mcs_label = _replace_double_quotes(job_start_msg->mcs_label);
2635 	job.name = _replace_double_quotes(job_start_msg->name);
2636 	job.nodes = job_start_msg->nodes;
2637 	job.network = job_start_msg->node_inx;
2638 	job.partition = job_start_msg->partition;
2639 	details.min_cpus = job_start_msg->req_cpus;
2640 	details.pn_min_memory = job_start_msg->req_mem;
2641 	job.qos_id = job_start_msg->qos_id;
2642 	job.resv_id = job_start_msg->resv_id;
2643 	job.priority = job_start_msg->priority;
2644 	job.start_protocol_ver = slurmdbd_conn->conn->version;
2645 	job.start_time = job_start_msg->start_time;
2646 	job.time_limit = job_start_msg->timelimit;
2647 	job.tres_alloc_str = job_start_msg->tres_alloc_str;
2648 	job.tres_req_str = job_start_msg->tres_req_str;
2649 	job.gres_alloc = job_start_msg->gres_alloc;
2650 	job.gres_req = job_start_msg->gres_req;
2651 	job.gres_used = job_start_msg->gres_used;
2652 	job.wckey = _replace_double_quotes(job_start_msg->wckey);
2653 	details.work_dir = _replace_double_quotes(job_start_msg->work_dir);
2654 	details.submit_time = job_start_msg->submit_time;
2655 	job.db_flags = job_start_msg->db_flags;
2656 	details.features = _replace_double_quotes(job_start_msg->constraints);
2657 	job.state_reason_prev_db = job_start_msg->state_reason_prev;
2658 
2659 	job.array_recs = &array_recs;
2660 	job.details = &details;
2661 	job_ptr = &job;
2662 
2663 	if (job.job_state & JOB_RESIZING) {
2664 		job.resize_time = job_start_msg->eligible_time;
2665 		debug2("DBD_JOB_START: RESIZE CALL ID:%u NAME:%s INX:%"PRIu64,
2666 		       job_start_msg->job_id, job_start_msg->name,
2667 		       job.db_index);
2668 	} else if (job.start_time && !IS_JOB_PENDING(job_ptr)) {
2669 		debug2("DBD_JOB_START: START CALL ID:%u NAME:%s INX:%"PRIu64,
2670 		       job_start_msg->job_id, job_start_msg->name,
2671 		       job.db_index);
2672 	} else {
2673 		debug2("DBD_JOB_START: ELIGIBLE CALL ID:%u NAME:%s",
2674 		       job_start_msg->job_id, job_start_msg->name);
2675 	}
2676 	id_rc_msg->return_code = jobacct_storage_g_job_start(
2677 		slurmdbd_conn->db_conn, &job);
2678 	id_rc_msg->job_id = job.job_id;
2679 	id_rc_msg->db_index = job.db_index;
2680 
2681 	/* just in case job.wckey was set because we didn't send one */
2682 	if (!job_start_msg->wckey)
2683 		xfree(job.wckey);
2684 
2685 	if (!slurmdbd_conn->conn->rem_port) {
2686 		debug3("DBD_JOB_START: cluster not registered");
2687 		slurmdbd_conn->conn->rem_port =
2688 			clusteracct_storage_g_register_disconn_ctld(
2689 				slurmdbd_conn->db_conn,
2690 				slurmdbd_conn->conn->rem_host);
2691 
2692 		_add_registered_cluster(slurmdbd_conn);
2693 	}
2694 }
2695 
_reconfig(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2696 static int   _reconfig(slurmdbd_conn_t *slurmdbd_conn,
2697 		       persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
2698 {
2699 	int rc = SLURM_SUCCESS;
2700 	char *comment = NULL;
2701 
2702 	if (!_validate_super_user(*uid, slurmdbd_conn)) {
2703 		comment = "Your user doesn't have privilege to perform this action";
2704 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2705 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
2706 							ESLURM_ACCESS_DENIED,
2707 							comment,
2708 							DBD_MODIFY_WCKEYS);
2709 
2710 		return ESLURM_ACCESS_DENIED;
2711 	}
2712 
2713 	info("Reconfigure request received");
2714 	reconfig();
2715 
2716 	*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
2717 						rc, comment, DBD_RECONFIG);
2718 	return rc;
2719 
2720 }
2721 
_register_ctld(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2722 static int   _register_ctld(slurmdbd_conn_t *slurmdbd_conn,
2723 			    persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
2724 {
2725 	dbd_register_ctld_msg_t *register_ctld_msg = msg->data;
2726 	int rc = SLURM_SUCCESS;
2727 	char *comment = NULL;
2728 	slurmdb_cluster_cond_t cluster_q;
2729 	slurmdb_cluster_rec_t cluster;
2730 	dbd_list_msg_t list_msg = { NULL };
2731 	List cluster_list;
2732 
2733 	if (!_validate_slurm_user(*uid)) {
2734 		comment = "DBD_REGISTER_CTLD message from invalid uid";
2735 		error("CONN:%u %s %u",
2736 		      slurmdbd_conn->conn->fd, comment, *uid);
2737 		rc = ESLURM_ACCESS_DENIED;
2738 		goto end_it;
2739 	}
2740 
2741 	debug2("DBD_REGISTER_CTLD: called for %s(%u)",
2742 	       slurmdbd_conn->conn->cluster_name, register_ctld_msg->port);
2743 
2744 	/* Just to make sure we don't allow a NULL cluster name to attempt
2745 	   to connect.  This should never happen, but here just for
2746 	   sanity check.
2747 	*/
2748 	if (!slurmdbd_conn->conn->cluster_name) {
2749 		comment = "Must have a cluster name to register it";
2750 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2751 		rc = ESLURM_BAD_NAME;
2752 		goto end_it;
2753 	}
2754 
2755 	debug2("slurmctld at ip:%s, port:%d",
2756 	       slurmdbd_conn->conn->rem_host, register_ctld_msg->port);
2757 
2758 	slurmdb_init_cluster_cond(&cluster_q, 0);
2759 	slurmdb_init_cluster_rec(&cluster, 0);
2760 
2761 	cluster_q.cluster_list = list_create(NULL);
2762 	list_append(cluster_q.cluster_list, slurmdbd_conn->conn->cluster_name);
2763 	cluster.control_host = slurmdbd_conn->conn->rem_host;
2764 	cluster.control_port = register_ctld_msg->port;
2765 	cluster.dimensions = register_ctld_msg->dimensions;
2766 	cluster.flags = register_ctld_msg->flags;
2767 	cluster.plugin_id_select = register_ctld_msg->plugin_id_select;
2768 	cluster.rpc_version = slurmdbd_conn->conn->version;
2769 
2770 	cluster_list = acct_storage_g_get_clusters(slurmdbd_conn->db_conn, *uid,
2771 						   &cluster_q);
2772 	if (!cluster_list || errno) {
2773 		comment = slurm_strerror(errno);
2774 		rc = errno;
2775 	} else if (!list_count(cluster_list)) {
2776 		slurmdb_assoc_rec_t root_assoc;
2777 		List add_list = list_create(NULL);
2778 		list_append(add_list, &cluster);
2779 
2780 		slurmdb_init_assoc_rec(&root_assoc, 0);
2781 		cluster.root_assoc = &root_assoc;
2782 		cluster.name = slurmdbd_conn->conn->cluster_name;
2783 		rc = acct_storage_g_add_clusters(slurmdbd_conn->db_conn, *uid,
2784 						 add_list);
2785 		if (rc == ESLURM_ACCESS_DENIED)
2786 			comment = "Your user doesn't have privilege to perform this action";
2787 		else if (rc != SLURM_SUCCESS)
2788 			comment = "Failed to add/register cluster.";
2789 		slurmdb_free_assoc_rec_members(&root_assoc);
2790 		FREE_NULL_LIST(add_list);
2791 	} else if ((cluster.flags != NO_VAL) &&
2792 		   (cluster.flags & CLUSTER_FLAG_EXT) &&
2793 		   !(((slurmdb_cluster_rec_t *)list_peek(cluster_list))->flags &
2794 		     CLUSTER_FLAG_EXT)) {
2795 		comment = "Can't register to non-external cluster";
2796 		rc = ESLURM_ACCESS_DENIED;
2797 	}
2798 	FREE_NULL_LIST(cluster_list);
2799 	if (rc)
2800 		goto end_it;
2801 
2802 	list_msg.my_list = acct_storage_g_modify_clusters(
2803 		slurmdbd_conn->db_conn, *uid, &cluster_q, &cluster);
2804 	if (errno == EFAULT) {
2805 		comment = "Request to register was incomplete";
2806 		rc = SLURM_ERROR;
2807 	} else if (errno == ESLURM_ACCESS_DENIED) {
2808 		comment = "Your user doesn't have privilege to perform this action";
2809 		rc = ESLURM_ACCESS_DENIED;
2810 	} else if (errno == ESLURM_DB_CONNECTION) {
2811 		comment = slurm_strerror(errno);
2812 		rc = errno;
2813 	} else if (!list_msg.my_list || !list_count(list_msg.my_list)) {
2814 		comment = "This cluster hasn't been added to accounting yet";
2815 		rc = SLURM_ERROR;
2816 	}
2817 
2818 	FREE_NULL_LIST(list_msg.my_list);
2819 	FREE_NULL_LIST(cluster_q.cluster_list);
2820 
2821 end_it:
2822 
2823 	if (rc == SLURM_SUCCESS) {
2824 		slurmdbd_conn->conn->rem_port = register_ctld_msg->port;
2825 
2826 		_add_registered_cluster(slurmdbd_conn);
2827 	}
2828 
2829 	*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
2830 						rc, comment, DBD_REGISTER_CTLD);
2831 	return rc;
2832 }
2833 
_remove_accounts(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2834 static int   _remove_accounts(slurmdbd_conn_t *slurmdbd_conn,
2835 			      persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
2836 {
2837 	int rc = SLURM_SUCCESS;
2838 	dbd_cond_msg_t *get_msg = msg->data;
2839 	dbd_list_msg_t list_msg = { NULL };
2840 	char *comment = NULL;
2841 
2842 	debug2("DBD_REMOVE_ACCOUNTS: called");
2843 
2844 	if (!(list_msg.my_list = acct_storage_g_remove_accounts(
2845 		      slurmdbd_conn->db_conn, *uid, get_msg->cond))) {
2846 		if (errno == ESLURM_ACCESS_DENIED) {
2847 			comment = "Your user doesn't have privilege to perform this action";
2848 			rc = ESLURM_ACCESS_DENIED;
2849 		} else if (errno == SLURM_ERROR) {
2850 			comment = "Something was wrong with your query";
2851 			rc = SLURM_ERROR;
2852 		} else if (errno == SLURM_NO_CHANGE_IN_DATA) {
2853 			comment = "Request didn't affect anything";
2854 			rc = SLURM_SUCCESS;
2855 		} else if (errno == ESLURM_DB_CONNECTION) {
2856 			comment = slurm_strerror(errno);
2857 			rc = errno;
2858 		} else {
2859 			rc = errno;
2860 			if (!(comment = slurm_strerror(errno)))
2861 				comment = "Unknown issue";
2862 		}
2863 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2864 		*out_buffer = slurm_persist_make_rc_msg(
2865 			slurmdbd_conn->conn, rc, comment, DBD_REMOVE_ACCOUNTS);
2866 		return rc;
2867 	}
2868 	list_msg.return_code = errno;
2869 
2870 	*out_buffer = init_buf(1024);
2871 	pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
2872 	slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
2873 			       DBD_GOT_LIST, *out_buffer);
2874 	FREE_NULL_LIST(list_msg.my_list);
2875 
2876 	return rc;
2877 }
2878 
_remove_account_coords(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2879 static int   _remove_account_coords(slurmdbd_conn_t *slurmdbd_conn,
2880 				    persist_msg_t *msg, Buf *out_buffer,
2881 				    uint32_t *uid)
2882 {
2883 	int rc = SLURM_SUCCESS;
2884 	dbd_acct_coord_msg_t *get_msg = msg->data;
2885 	dbd_list_msg_t list_msg = { NULL };
2886 	char *comment = NULL;
2887 
2888 	debug2("DBD_REMOVE_ACCOUNT_COORDS: called");
2889 
2890 	/* All authentication needs to be done inside the plugin since we are
2891 	 * unable to know what accounts this request is talking about
2892 	 * until we process it through the database.
2893 	 */
2894 
2895 	if (!(list_msg.my_list = acct_storage_g_remove_coord(
2896 		      slurmdbd_conn->db_conn, *uid, get_msg->acct_list,
2897 		      get_msg->cond))) {
2898 		if (errno == ESLURM_ACCESS_DENIED) {
2899 			comment = "Your user doesn't have privilege to perform this action";
2900 			rc = ESLURM_ACCESS_DENIED;
2901 		} else if (errno == SLURM_ERROR) {
2902 			comment = "Something was wrong with your query";
2903 			rc = SLURM_ERROR;
2904 		} else if (errno == SLURM_NO_CHANGE_IN_DATA) {
2905 			comment = "Request didn't affect anything";
2906 			rc = SLURM_SUCCESS;
2907 		} else if (errno == ESLURM_DB_CONNECTION) {
2908 			comment = slurm_strerror(errno);
2909 			rc = errno;
2910 		} else {
2911 			rc = errno;
2912 			if (!(comment = slurm_strerror(errno)))
2913 				comment = "Unknown issue";
2914 		}
2915 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2916 		*out_buffer = slurm_persist_make_rc_msg(
2917 			slurmdbd_conn->conn, rc, comment,
2918 			DBD_REMOVE_ACCOUNT_COORDS);
2919 		return rc;
2920 	}
2921 	list_msg.return_code = SLURM_SUCCESS;
2922 
2923 	*out_buffer = init_buf(1024);
2924 	pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
2925 	slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
2926 			       DBD_GOT_LIST, *out_buffer);
2927 	FREE_NULL_LIST(list_msg.my_list);
2928 
2929 	return rc;
2930 }
2931 
_remove_assocs(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2932 static int   _remove_assocs(slurmdbd_conn_t *slurmdbd_conn,
2933 			    persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
2934 {
2935 	int rc = SLURM_SUCCESS;
2936 	dbd_cond_msg_t *get_msg = msg->data;
2937 	dbd_list_msg_t list_msg = { NULL };
2938 	char *comment = NULL;
2939 
2940 	debug2("DBD_REMOVE_ASSOCS: called");
2941 
2942 	/* All authentication needs to be done inside the plugin since we are
2943 	 * unable to know what accounts this request is talking about
2944 	 * until we process it through the database.
2945 	 */
2946 
2947 	if (!(list_msg.my_list = acct_storage_g_remove_assocs(
2948 		      slurmdbd_conn->db_conn, *uid, get_msg->cond))) {
2949 		if (errno == ESLURM_ACCESS_DENIED) {
2950 			comment = "Your user doesn't have privilege to perform this action";
2951 			rc = ESLURM_ACCESS_DENIED;
2952 		} else if (errno == SLURM_ERROR) {
2953 			comment = "Something was wrong with your query";
2954 			rc = SLURM_ERROR;
2955 		} else if (errno == SLURM_NO_CHANGE_IN_DATA) {
2956 			comment = "Request didn't affect anything";
2957 			rc = SLURM_SUCCESS;
2958 		} else if (errno == ESLURM_DB_CONNECTION) {
2959 			comment = slurm_strerror(errno);
2960 			rc = errno;
2961 		} else {
2962 			rc = errno;
2963 			if (!(comment = slurm_strerror(errno)))
2964 				comment = "Unknown issue";
2965 		}
2966 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
2967 		*out_buffer = slurm_persist_make_rc_msg(
2968 			slurmdbd_conn->conn, rc, comment, DBD_REMOVE_ASSOCS);
2969 		return rc;
2970 	}
2971 	list_msg.return_code = errno;
2972 
2973 	*out_buffer = init_buf(1024);
2974 	pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
2975 	slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
2976 			       DBD_GOT_LIST, *out_buffer);
2977 	FREE_NULL_LIST(list_msg.my_list);
2978 
2979 	return rc;
2980 
2981 }
2982 
_remove_clusters(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)2983 static int   _remove_clusters(slurmdbd_conn_t *slurmdbd_conn,
2984 			      persist_msg_t *msg, Buf *out_buffer,
2985 			      uint32_t *uid)
2986 {
2987 	int rc = SLURM_SUCCESS;
2988 	dbd_cond_msg_t *get_msg = msg->data;
2989 	dbd_list_msg_t list_msg = { NULL };
2990 	char *comment = NULL;
2991 
2992 	debug2("DBD_REMOVE_CLUSTERS: called");
2993 
2994 	if (!(list_msg.my_list = acct_storage_g_remove_clusters(
2995 		      slurmdbd_conn->db_conn, *uid, get_msg->cond))) {
2996 		if (errno == ESLURM_ACCESS_DENIED) {
2997 			comment = "Your user doesn't have privilege to perform this action";
2998 			rc = ESLURM_ACCESS_DENIED;
2999 		} else if (errno == SLURM_ERROR) {
3000 			comment = "Something was wrong with your query";
3001 			rc = SLURM_ERROR;
3002 		} else if (errno == SLURM_NO_CHANGE_IN_DATA) {
3003 			comment = "Request didn't affect anything";
3004 			rc = SLURM_SUCCESS;
3005 		} else if (errno == ESLURM_DB_CONNECTION) {
3006 			comment = slurm_strerror(errno);
3007 			rc = errno;
3008 		} else {
3009 			rc = errno;
3010 			if (!(comment = slurm_strerror(errno)))
3011 				comment = "Unknown issue";
3012 		}
3013 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
3014 		*out_buffer = slurm_persist_make_rc_msg(
3015 			slurmdbd_conn->conn, rc, comment, DBD_REMOVE_CLUSTERS);
3016 		return rc;
3017 	}
3018 	list_msg.return_code = errno;
3019 
3020 	*out_buffer = init_buf(1024);
3021 	pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
3022 	slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
3023 			       DBD_GOT_LIST, *out_buffer);
3024 	FREE_NULL_LIST(list_msg.my_list);
3025 
3026 	return rc;
3027 }
3028 
_remove_federations(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)3029 static int _remove_federations(slurmdbd_conn_t *slurmdbd_conn,
3030 			       persist_msg_t *msg,
3031 			       Buf *out_buffer, uint32_t *uid)
3032 {
3033 	int rc = SLURM_SUCCESS;
3034 	dbd_cond_msg_t *get_msg = msg->data;
3035 	dbd_list_msg_t list_msg = { NULL };
3036 	char *comment = NULL;
3037 
3038 	debug2("DBD_REMOVE_FEDERATIONS: called");
3039 
3040 	if (!(list_msg.my_list = acct_storage_g_remove_federations(
3041 		      slurmdbd_conn->db_conn, *uid, get_msg->cond))) {
3042 		if (errno == ESLURM_ACCESS_DENIED) {
3043 			comment = "Your user doesn't have privilege to perform "
3044 				"this action";
3045 			rc = ESLURM_ACCESS_DENIED;
3046 		} else if (errno == SLURM_ERROR) {
3047 			comment = "Something was wrong with your query";
3048 			rc = SLURM_ERROR;
3049 		} else if (errno == SLURM_NO_CHANGE_IN_DATA) {
3050 			comment = "Request didn't affect anything";
3051 			rc = SLURM_SUCCESS;
3052 		} else if (errno == ESLURM_DB_CONNECTION) {
3053 			comment = slurm_strerror(errno);
3054 			rc = errno;
3055 		} else {
3056 			rc = errno;
3057 			if (!(comment = slurm_strerror(errno)))
3058 				comment = "Unknown issue";
3059 		}
3060 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
3061 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
3062 							rc, comment,
3063 							DBD_REMOVE_FEDERATIONS);
3064 		return rc;
3065 	}
3066 	list_msg.return_code = errno;
3067 
3068 	*out_buffer = init_buf(1024);
3069 	pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
3070 	slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
3071 			       DBD_GOT_LIST, *out_buffer);
3072 	FREE_NULL_LIST(list_msg.my_list);
3073 
3074 	return rc;
3075 }
3076 
_remove_qos(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)3077 static int   _remove_qos(slurmdbd_conn_t *slurmdbd_conn,
3078 			 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
3079 {
3080 	int rc = SLURM_SUCCESS;
3081 	dbd_cond_msg_t *get_msg = msg->data;
3082 	dbd_list_msg_t list_msg = { NULL };
3083 	char *comment = NULL;
3084 
3085 	debug2("DBD_REMOVE_QOS: called");
3086 
3087 	if (!(list_msg.my_list = acct_storage_g_remove_qos(
3088 		      slurmdbd_conn->db_conn, *uid, get_msg->cond))) {
3089 		if (errno == ESLURM_ACCESS_DENIED) {
3090 			comment = "Your user doesn't have privilege to perform this action";
3091 			rc = ESLURM_ACCESS_DENIED;
3092 		} else if (errno == SLURM_ERROR) {
3093 			comment = "Something was wrong with your query";
3094 			rc = SLURM_ERROR;
3095 		} else if (errno == SLURM_NO_CHANGE_IN_DATA) {
3096 			comment = "Request didn't affect anything";
3097 			rc = SLURM_SUCCESS;
3098 		} else if (errno == ESLURM_DB_CONNECTION) {
3099 			comment = slurm_strerror(errno);
3100 			rc = errno;
3101 		} else {
3102 			rc = errno;
3103 			if (!(comment = slurm_strerror(errno)))
3104 				comment = "Unknown issue";
3105 		}
3106 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
3107 		*out_buffer = slurm_persist_make_rc_msg(
3108 			slurmdbd_conn->conn, rc, comment, DBD_REMOVE_QOS);
3109 		return rc;
3110 	}
3111 	list_msg.return_code = SLURM_SUCCESS;
3112 
3113 	*out_buffer = init_buf(1024);
3114 	pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
3115 	slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
3116 			       DBD_GOT_LIST, *out_buffer);
3117 	FREE_NULL_LIST(list_msg.my_list);
3118 
3119 	return rc;
3120 }
3121 
_remove_res(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)3122 static int _remove_res(slurmdbd_conn_t *slurmdbd_conn,
3123 		       persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
3124 {
3125 	int rc = SLURM_SUCCESS;
3126 	dbd_cond_msg_t *get_msg = msg->data;
3127 	dbd_list_msg_t list_msg = { NULL };
3128 	char *comment = NULL;
3129 
3130 	debug2("DBD_REMOVE_RES: called");
3131 
3132 	if (!(list_msg.my_list = acct_storage_g_remove_res(
3133 		      slurmdbd_conn->db_conn, *uid, get_msg->cond))) {
3134 		if (errno == ESLURM_ACCESS_DENIED) {
3135 			comment = "Your user doesn't have privilege to perform "
3136 				"this action";
3137 			rc = ESLURM_ACCESS_DENIED;
3138 		} else if (errno == SLURM_ERROR) {
3139 			comment = "Something was wrong with your query";
3140 			rc = SLURM_ERROR;
3141 		} else if (errno == SLURM_NO_CHANGE_IN_DATA) {
3142 			comment = "Request didn't affect anything";
3143 			rc = SLURM_SUCCESS;
3144 		} else if (errno == ESLURM_DB_CONNECTION) {
3145 			comment = slurm_strerror(errno);
3146 			rc = errno;
3147 		} else {
3148 			rc = errno;
3149 			if (!(comment = slurm_strerror(errno)))
3150 				comment = "Unknown issue";
3151 		}
3152 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
3153 		*out_buffer = slurm_persist_make_rc_msg(
3154 			slurmdbd_conn->conn, rc, comment, DBD_REMOVE_RES);
3155 		return rc;
3156 	}
3157 	list_msg.return_code = errno;
3158 	*out_buffer = init_buf(1024);
3159 	pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
3160 	slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
3161 			       DBD_GOT_LIST, *out_buffer);
3162 	FREE_NULL_LIST(list_msg.my_list);
3163 
3164 	return rc;
3165 }
3166 
_remove_users(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)3167 static int   _remove_users(slurmdbd_conn_t *slurmdbd_conn,
3168 			   persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
3169 {
3170 	int rc = SLURM_SUCCESS;
3171 	dbd_cond_msg_t *get_msg = msg->data;
3172 	dbd_list_msg_t list_msg = { NULL };
3173 	char *comment = NULL;
3174 
3175 	debug2("DBD_REMOVE_USERS: called");
3176 
3177 	if (!(list_msg.my_list = acct_storage_g_remove_users(
3178 		      slurmdbd_conn->db_conn, *uid, get_msg->cond))) {
3179 		if (errno == ESLURM_ACCESS_DENIED) {
3180 			comment = "Your user doesn't have privilege to perform this action";
3181 			rc = ESLURM_ACCESS_DENIED;
3182 		} else if (errno == SLURM_ERROR) {
3183 			comment = "Something was wrong with your query";
3184 			rc = SLURM_ERROR;
3185 		} else if (errno == SLURM_NO_CHANGE_IN_DATA) {
3186 			comment = "Request didn't affect anything";
3187 			rc = SLURM_SUCCESS;
3188 		} else if (errno == ESLURM_DB_CONNECTION) {
3189 			comment = slurm_strerror(errno);
3190 			rc = errno;
3191 		} else {
3192 			rc = errno;
3193 			if (!(comment = slurm_strerror(errno)))
3194 				comment = "Unknown issue";
3195 		}
3196 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
3197 		*out_buffer = slurm_persist_make_rc_msg(
3198 			slurmdbd_conn->conn, rc, comment, DBD_REMOVE_USERS);
3199 		return rc;
3200 	}
3201 	list_msg.return_code = errno;
3202 
3203 	*out_buffer = init_buf(1024);
3204 	pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
3205 	slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
3206 			       DBD_GOT_LIST, *out_buffer);
3207 	FREE_NULL_LIST(list_msg.my_list);
3208 
3209 	return rc;
3210 }
3211 
_remove_wckeys(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)3212 static int   _remove_wckeys(slurmdbd_conn_t *slurmdbd_conn,
3213 			    persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
3214 {
3215 	int rc = SLURM_SUCCESS;
3216 	dbd_cond_msg_t *get_msg = msg->data;
3217 	dbd_list_msg_t list_msg = { NULL };
3218 	char *comment = NULL;
3219 
3220 	debug2("DBD_REMOVE_WCKEYS: called");
3221 
3222 	if (!(list_msg.my_list = acct_storage_g_remove_wckeys(
3223 		      slurmdbd_conn->db_conn, *uid, get_msg->cond))) {
3224 		if (errno == ESLURM_ACCESS_DENIED) {
3225 			comment = "Your user doesn't have privilege to perform this action";
3226 			rc = ESLURM_ACCESS_DENIED;
3227 		} else if (errno == SLURM_ERROR) {
3228 			comment = "Something was wrong with your query";
3229 			rc = SLURM_ERROR;
3230 		} else if (errno == SLURM_NO_CHANGE_IN_DATA) {
3231 			comment = "Request didn't affect anything";
3232 			rc = SLURM_SUCCESS;
3233 		} else if (errno == ESLURM_DB_CONNECTION) {
3234 			comment = slurm_strerror(errno);
3235 			rc = errno;
3236 		} else {
3237 			rc = errno;
3238 			if (!(comment = slurm_strerror(errno)))
3239 				comment = "Unknown issue";
3240 		}
3241 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
3242 		*out_buffer = slurm_persist_make_rc_msg(
3243 			slurmdbd_conn->conn, rc, comment, DBD_REMOVE_WCKEYS);
3244 		return rc;
3245 	}
3246 	list_msg.return_code = SLURM_SUCCESS;
3247 
3248 	*out_buffer = init_buf(1024);
3249 	pack16((uint16_t) DBD_GOT_LIST, *out_buffer);
3250 	slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
3251 			       DBD_GOT_LIST, *out_buffer);
3252 	FREE_NULL_LIST(list_msg.my_list);
3253 
3254 	return rc;
3255 }
3256 
_remove_reservation(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)3257 static int _remove_reservation(slurmdbd_conn_t *slurmdbd_conn,
3258 			       persist_msg_t *msg, Buf *out_buffer,
3259 			       uint32_t *uid)
3260 {
3261 	int rc = SLURM_SUCCESS;
3262 	dbd_rec_msg_t *rec_msg = msg->data;
3263 	char *comment = NULL;
3264 
3265 	if (!_validate_slurm_user(*uid)) {
3266 		comment = "DBD_REMOVE_RESV message from invalid uid";
3267 		error("DBD_REMOVE_RESV message from invalid uid %u", *uid);
3268 		rc = ESLURM_ACCESS_DENIED;
3269 		goto end_it;
3270 	}
3271 
3272 	debug2("DBD_REMOVE_RESV: called");
3273 
3274 	rc = acct_storage_g_remove_reservation(slurmdbd_conn->db_conn,
3275 					       rec_msg->rec);
3276 
3277 end_it:
3278 	*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
3279 						rc, comment, DBD_REMOVE_RESV);
3280 	return rc;
3281 }
3282 
_roll_usage(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)3283 static int   _roll_usage(slurmdbd_conn_t *slurmdbd_conn,
3284 			 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
3285 {
3286 	dbd_roll_usage_msg_t *get_msg = msg->data;
3287 	int rc = SLURM_SUCCESS;
3288 	char *comment = NULL;
3289 	List rollup_stats_list = NULL;
3290 	DEF_TIMERS;
3291 
3292 	info("DBD_ROLL_USAGE: called");
3293 
3294 	if (!_validate_operator(*uid, slurmdbd_conn)) {
3295 		comment = "Your user doesn't have privilege to perform this action";
3296 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
3297 		rc = ESLURM_ACCESS_DENIED;
3298 		goto end_it;
3299 	}
3300 
3301 	START_TIMER;
3302 	rc = acct_storage_g_roll_usage(slurmdbd_conn->db_conn,
3303 				       get_msg->start, get_msg->end,
3304 				       get_msg->archive_data,
3305 				       &rollup_stats_list);
3306 	END_TIMER;
3307 	handle_rollup_stats(rollup_stats_list, DELTA_TIMER, 1);
3308 	FREE_NULL_LIST(rollup_stats_list);
3309 
3310 end_it:
3311 	*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
3312 						rc, comment, DBD_ROLL_USAGE);
3313 	return rc;
3314 }
3315 
_send_mult_job_start(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)3316 static int   _send_mult_job_start(slurmdbd_conn_t *slurmdbd_conn,
3317 				  persist_msg_t *msg, Buf *out_buffer,
3318 				  uint32_t *uid)
3319 {
3320 	dbd_list_msg_t *get_msg = msg->data;
3321 	dbd_list_msg_t list_msg = { NULL };
3322 	char *comment = NULL;
3323 	ListIterator itr = NULL;
3324 	dbd_job_start_msg_t *job_start_msg;
3325 	dbd_id_rc_msg_t *id_rc_msg;
3326 	/* DEF_TIMERS; */
3327 
3328 	if (!_validate_slurm_user(*uid)) {
3329 		comment = "DBD_SEND_MULT_JOB_START message from invalid uid";
3330 		error("%s %u", comment, *uid);
3331 		*out_buffer = slurm_persist_make_rc_msg(
3332 			slurmdbd_conn->conn,
3333 			ESLURM_ACCESS_DENIED, comment,
3334 			DBD_SEND_MULT_JOB_START);
3335 		return SLURM_ERROR;
3336 	}
3337 
3338 	list_msg.my_list = list_create(slurmdbd_free_id_rc_msg);
3339 	/* START_TIMER; */
3340 	itr = list_iterator_create(get_msg->my_list);
3341 	while ((job_start_msg = list_next(itr))) {
3342 	        id_rc_msg = xmalloc(sizeof(dbd_id_rc_msg_t));
3343 		list_append(list_msg.my_list, id_rc_msg);
3344 
3345 		_process_job_start(slurmdbd_conn, job_start_msg, id_rc_msg);
3346 	}
3347 	list_iterator_destroy(itr);
3348 	/* END_TIMER; */
3349 	/* info("%d multi job took %s", */
3350 	/*      list_count(get_msg->my_list), TIME_STR); */
3351 
3352 	*out_buffer = init_buf(1024);
3353 	pack16((uint16_t) DBD_GOT_MULT_JOB_START, *out_buffer);
3354 	slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
3355 			       DBD_GOT_MULT_JOB_START, *out_buffer);
3356 	FREE_NULL_LIST(list_msg.my_list);
3357 
3358 	return SLURM_SUCCESS;
3359 }
3360 
_send_mult_msg(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)3361 static int   _send_mult_msg(slurmdbd_conn_t *slurmdbd_conn,
3362 			    persist_msg_t *msg, Buf *out_buffer,
3363 			    uint32_t *uid)
3364 {
3365 	dbd_list_msg_t *get_msg = msg->data;
3366 	dbd_list_msg_t list_msg = { NULL };
3367 	char *comment = NULL;
3368 	ListIterator itr = NULL;
3369 	Buf req_buf = NULL, ret_buf = NULL;
3370 	int rc = SLURM_SUCCESS;
3371 	/* DEF_TIMERS; */
3372 
3373 	if (!_validate_slurm_user(*uid)) {
3374 		comment = "DBD_SEND_MULT_MSG message from invalid uid";
3375 		error("%s %u", comment, *uid);
3376 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
3377 							ESLURM_ACCESS_DENIED,
3378 							comment,
3379 							DBD_SEND_MULT_MSG);
3380 		return SLURM_ERROR;
3381 	}
3382 
3383 	list_msg.my_list = list_create(slurmdbd_free_buffer);
3384 	/* START_TIMER; */
3385 	itr = list_iterator_create(get_msg->my_list);
3386 	while ((req_buf = list_next(itr))) {
3387 		persist_msg_t sub_msg;
3388 
3389 		ret_buf = NULL;
3390 
3391 		rc = slurm_persist_conn_process_msg(
3392 			slurmdbd_conn->conn, &sub_msg,
3393 			get_buf_data(req_buf),
3394 			size_buf(req_buf), &ret_buf, 0);
3395 
3396 		if (rc == SLURM_SUCCESS) {
3397 			rc = proc_req(slurmdbd_conn, &sub_msg, &ret_buf, uid);
3398 			slurmdbd_free_msg(&sub_msg);
3399 		}
3400 
3401 		if (ret_buf)
3402 			list_append(list_msg.my_list, ret_buf);
3403 		if (rc != SLURM_SUCCESS)
3404 			break;
3405 	}
3406 	list_iterator_destroy(itr);
3407 	/* END_TIMER; */
3408 	/* info("%d multi took %s", list_count(get_msg->my_list), TIME_STR); */
3409 
3410 	*out_buffer = init_buf(1024);
3411 	pack16((uint16_t) DBD_GOT_MULT_MSG, *out_buffer);
3412 	slurmdbd_pack_list_msg(&list_msg, slurmdbd_conn->conn->version,
3413 			       DBD_GOT_MULT_MSG, *out_buffer);
3414 	FREE_NULL_LIST(list_msg.my_list);
3415 
3416 	return SLURM_SUCCESS;
3417 }
3418 
_step_complete(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)3419 static int  _step_complete(slurmdbd_conn_t *slurmdbd_conn,
3420 			   persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
3421 {
3422 	dbd_step_comp_msg_t *step_comp_msg = msg->data;
3423 	step_record_t step;
3424 	job_record_t job;
3425 	struct job_details details;
3426 	int rc = SLURM_SUCCESS;
3427 	char *comment = NULL;
3428 
3429 	if (!_validate_slurm_user(*uid)) {
3430 		comment = "DBD_STEP_COMPLETE message from invalid uid";
3431 		error("%s %u", comment, *uid);
3432 		rc = ESLURM_ACCESS_DENIED;
3433 		goto end_it;
3434 	}
3435 
3436 	debug2("DBD_STEP_COMPLETE: ID:%u.%u SUBMIT:%lu",
3437 	       step_comp_msg->job_id, step_comp_msg->step_id,
3438 	       (unsigned long) step_comp_msg->job_submit_time);
3439 
3440 	memset(&step, 0, sizeof(step_record_t));
3441 	memset(&job, 0, sizeof(job_record_t));
3442 	memset(&details, 0, sizeof(struct job_details));
3443 
3444 	job.assoc_id = step_comp_msg->assoc_id;
3445 	if (step_comp_msg->db_index != NO_VAL64)
3446 		job.db_index = step_comp_msg->db_index;
3447 	job.end_time = step_comp_msg->end_time;
3448 	step.exit_code = step_comp_msg->exit_code;
3449 	step.jobacct = step_comp_msg->jobacct;
3450 	job.job_id = step_comp_msg->job_id;
3451 	step.requid = step_comp_msg->req_uid;
3452 	job.start_protocol_ver = slurmdbd_conn->conn->version;
3453 	job.start_time = step_comp_msg->start_time;
3454 	job.tres_alloc_str = step_comp_msg->job_tres_alloc_str;
3455 	step.state = step_comp_msg->state;
3456 	step.step_id = step_comp_msg->step_id;
3457 	details.submit_time = step_comp_msg->job_submit_time;
3458 	details.num_tasks = step_comp_msg->total_tasks;
3459 
3460 	job.details = &details;
3461 	step.job_ptr = &job;
3462 
3463 	rc = jobacct_storage_g_step_complete(slurmdbd_conn->db_conn, &step);
3464 
3465 	if (rc && errno == 740) /* meaning data is already there */
3466 		rc = SLURM_SUCCESS;
3467 	/* just in case this gets set we need to clear it */
3468 	xfree(job.wckey);
3469 
3470 	if (!slurmdbd_conn->conn->rem_port) {
3471 		debug3("DBD_STEP_COMPLETE: cluster not registered");
3472 		slurmdbd_conn->conn->rem_port =
3473 			clusteracct_storage_g_register_disconn_ctld(
3474 				slurmdbd_conn->db_conn,
3475 				slurmdbd_conn->conn->rem_host);
3476 
3477 		_add_registered_cluster(slurmdbd_conn);
3478 	}
3479 
3480 end_it:
3481 	*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
3482 						rc, comment, DBD_STEP_COMPLETE);
3483 	return rc;
3484 }
3485 
_step_start(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)3486 static int  _step_start(slurmdbd_conn_t *slurmdbd_conn,
3487 			persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
3488 {
3489 	dbd_step_start_msg_t *step_start_msg = msg->data;
3490 	step_record_t step;
3491 	job_record_t job;
3492 	struct job_details details;
3493 	slurm_step_layout_t layout;
3494 	int rc = SLURM_SUCCESS;
3495 	char *comment = NULL;
3496 
3497 	if (!_validate_slurm_user(*uid)) {
3498 		comment = "DBD_STEP_START message from invalid uid";
3499 		error("%s %u", comment, *uid);
3500 		rc = ESLURM_ACCESS_DENIED;
3501 		goto end_it;
3502 	}
3503 
3504 	debug2("DBD_STEP_START: ID:%u.%u NAME:%s SUBMIT:%lu",
3505 	       step_start_msg->job_id, step_start_msg->step_id,
3506 	       step_start_msg->name,
3507 	       (unsigned long) step_start_msg->job_submit_time);
3508 
3509 	memset(&step, 0, sizeof(step_record_t));
3510 	memset(&job, 0, sizeof(job_record_t));
3511 	memset(&details, 0, sizeof(struct job_details));
3512 	memset(&layout, 0, sizeof(slurm_step_layout_t));
3513 
3514 	job.assoc_id = step_start_msg->assoc_id;
3515 	if (step_start_msg->db_index != NO_VAL64)
3516 		job.db_index = step_start_msg->db_index;
3517 	job.job_id = step_start_msg->job_id;
3518 	step.name = step_start_msg->name;
3519 	job.nodes = step_start_msg->nodes;
3520 	step.network = step_start_msg->node_inx;
3521 	job.start_protocol_ver = slurmdbd_conn->conn->version;
3522 	step.start_time = step_start_msg->start_time;
3523 	details.submit_time = step_start_msg->job_submit_time;
3524 	step.step_id = step_start_msg->step_id;
3525 	details.num_tasks = step_start_msg->total_tasks;
3526 	step.cpu_freq_min = step_start_msg->req_cpufreq_min;
3527 	step.cpu_freq_max = step_start_msg->req_cpufreq_max;
3528 	step.cpu_freq_gov = step_start_msg->req_cpufreq_gov;
3529 	step.tres_alloc_str = step_start_msg->tres_alloc_str;
3530 
3531 	layout.node_cnt = step_start_msg->node_cnt;
3532 	layout.task_dist = step_start_msg->task_dist;
3533 
3534 	job.details = &details;
3535 	step.job_ptr = &job;
3536 	step.step_layout = &layout;
3537 
3538 	rc = jobacct_storage_g_step_start(slurmdbd_conn->db_conn, &step);
3539 
3540 	if (rc && errno == 740) /* meaning data is already there */
3541 		rc = SLURM_SUCCESS;
3542 
3543 	/* just in case this gets set we need to clear it */
3544 	xfree(job.wckey);
3545 
3546 	if (!slurmdbd_conn->conn->rem_port) {
3547 		debug3("DBD_STEP_START: cluster not registered");
3548 		slurmdbd_conn->conn->rem_port =
3549 			clusteracct_storage_g_register_disconn_ctld(
3550 				slurmdbd_conn->db_conn,
3551 				slurmdbd_conn->conn->rem_host);
3552 
3553 		_add_registered_cluster(slurmdbd_conn);
3554 	}
3555 
3556 end_it:
3557 	*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
3558 						rc, comment, DBD_STEP_START);
3559 	return rc;
3560 }
3561 
_get_stats(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)3562 static int  _get_stats(slurmdbd_conn_t *slurmdbd_conn,
3563 		       persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
3564 {
3565 	int rc = SLURM_SUCCESS;
3566 	char *comment = NULL;
3567 
3568 	if (!_validate_super_user(*uid, slurmdbd_conn)) {
3569 		comment = "Your user doesn't have privilege to perform this action";
3570 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
3571 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
3572 							ESLURM_ACCESS_DENIED,
3573 							comment, DBD_GET_STATS);
3574 
3575 		return ESLURM_ACCESS_DENIED;
3576 	}
3577 
3578 	debug2("Get stats request received from UID %u", *uid);
3579 	*out_buffer = init_buf(32 * 1024);
3580 	pack16((uint16_t) DBD_GOT_STATS, *out_buffer);
3581 	slurm_mutex_lock(&rpc_mutex);
3582 	slurmdb_pack_stats_msg(&rpc_stats, slurmdbd_conn->conn->version,
3583 			       *out_buffer);
3584 	slurm_mutex_unlock(&rpc_mutex);
3585 
3586 	return rc;
3587 }
3588 
_clear_stats(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)3589 static int  _clear_stats(slurmdbd_conn_t *slurmdbd_conn,
3590 			 persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
3591 {
3592 	int rc = SLURM_SUCCESS;
3593 	char *comment = NULL;
3594 
3595 	if (!_validate_super_user(*uid, slurmdbd_conn)) {
3596 		comment = "Your user doesn't have privilege to perform this action";
3597 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
3598 		*out_buffer = slurm_persist_make_rc_msg(
3599 			slurmdbd_conn->conn,
3600 			ESLURM_ACCESS_DENIED,
3601 			comment, DBD_CLEAR_STATS);
3602 
3603 		return ESLURM_ACCESS_DENIED;
3604 	}
3605 
3606 	info("Clear stats request received from UID %u", *uid);
3607 
3608 	init_dbd_stats();
3609 
3610 	*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
3611 						rc, comment, DBD_CLEAR_STATS);
3612 	return rc;
3613 }
3614 
_shutdown(slurmdbd_conn_t * slurmdbd_conn,persist_msg_t * msg,Buf * out_buffer,uint32_t * uid)3615 static int  _shutdown(slurmdbd_conn_t *slurmdbd_conn,
3616 		      persist_msg_t *msg, Buf *out_buffer, uint32_t *uid)
3617 {
3618 	int rc = SLURM_SUCCESS;
3619 	char *comment = NULL;
3620 
3621 	if (!_validate_super_user(*uid, slurmdbd_conn)) {
3622 		comment = "Your user doesn't have privilege to perform this action";
3623 		error("CONN:%u %s", slurmdbd_conn->conn->fd, comment);
3624 		*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
3625 							ESLURM_ACCESS_DENIED,
3626 							comment, DBD_SHUTDOWN);
3627 
3628 		return ESLURM_ACCESS_DENIED;
3629 	}
3630 
3631 	info("Shutdown request received from UID %u", *uid);
3632 	pthread_kill(signal_handler_thread, SIGTERM);
3633 
3634 	*out_buffer = slurm_persist_make_rc_msg(slurmdbd_conn->conn,
3635 						rc, comment, DBD_SHUTDOWN);
3636 	return rc;
3637 }
3638