1 /*
2  * Copyright (c) 2015-2017 Red Hat, Inc.
3  *
4  * All rights reserved.
5  *
6  * Author: Jan Friesse (jfriesse@redhat.com)
7  *
8  * This software licensed under BSD license, the text of which follows:
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions are met:
12  *
13  * - Redistributions of source code must retain the above copyright notice,
14  *   this list of conditions and the following disclaimer.
15  * - Redistributions in binary form must reproduce the above copyright notice,
16  *   this list of conditions and the following disclaimer in the documentation
17  *   and/or other materials provided with the distribution.
18  * - Neither the name of the Red Hat, Inc. nor the names of its
19  *   contributors may be used to endorse or promote products derived from this
20  *   software without specific prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
23  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
26  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
27  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
28  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
29  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
30  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
31  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
32  * THE POSSIBILITY OF SUCH DAMAGE.
33  */
34 
35 #include "qdevice-cmap.h"
36 #include "qdevice-net-poll.h"
37 #include "qdevice-log.h"
38 #include "qdevice-net-send.h"
39 #include "qdevice-net-socket.h"
40 #include "qdevice-votequorum.h"
41 #include "qdevice-ipc.h"
42 #include "qdevice-net-poll-array-user-data.h"
43 #include "qdevice-heuristics.h"
44 #include "qdevice-heuristics-cmd.h"
45 
46 /*
47  * Needed for creating nspr handle from unix fd
48  */
49 #include <private/pprio.h>
50 
51 static void
qdevice_net_poll_read_socket(struct qdevice_net_instance * instance)52 qdevice_net_poll_read_socket(struct qdevice_net_instance *instance)
53 {
54 
55 	if (qdevice_net_socket_read(instance) == -1) {
56 		instance->schedule_disconnect = 1;
57 	}
58 }
59 
60 static void
qdevice_net_poll_read_votequorum(struct qdevice_net_instance * instance)61 qdevice_net_poll_read_votequorum(struct qdevice_net_instance *instance)
62 {
63 
64 	if (qdevice_votequorum_dispatch(instance->qdevice_instance_ptr) == -1) {
65 		instance->schedule_disconnect = 1;
66 		instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_COROSYNC_CONNECTION_CLOSED;
67 	}
68 }
69 
70 static void
qdevice_net_poll_read_cmap(struct qdevice_net_instance * instance)71 qdevice_net_poll_read_cmap(struct qdevice_net_instance *instance)
72 {
73 
74 	if (qdevice_cmap_dispatch(instance->qdevice_instance_ptr) == -1) {
75 		instance->schedule_disconnect = 1;
76 		instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_COROSYNC_CONNECTION_CLOSED;
77 	}
78 }
79 
80 static void
qdevice_net_poll_write_socket(struct qdevice_net_instance * instance,const PRPollDesc * pfd)81 qdevice_net_poll_write_socket(struct qdevice_net_instance *instance, const PRPollDesc *pfd)
82 {
83 	int res;
84 
85 	if (instance->state == QDEVICE_NET_INSTANCE_STATE_WAITING_CONNECT) {
86 		res = nss_sock_non_blocking_client_succeeded(pfd);
87 		if (res == -1) {
88 			/*
89 			 * Connect failed -> try next
90 			 */
91 			res = nss_sock_non_blocking_client_try_next(&instance->non_blocking_client);
92 			if (res == -1) {
93 				qdevice_log_nss(LOG_ERR, "Can't connect to qnetd host.");
94 				nss_sock_non_blocking_client_destroy(&instance->non_blocking_client);
95 			}
96 		} else if (res == 0) {
97 			/*
98 			 * Poll again
99 			 */
100 		} else if (res == 1) {
101 			/*
102 			 * Connect success
103 			 */
104 			instance->socket = instance->non_blocking_client.socket;
105 			nss_sock_non_blocking_client_destroy(&instance->non_blocking_client);
106 			instance->non_blocking_client.socket = NULL;
107 
108 			instance->state = QDEVICE_NET_INSTANCE_STATE_SENDING_PREINIT_REPLY;
109 
110 			qdevice_log(LOG_DEBUG, "Sending preinit msg to qnetd");
111 			if (qdevice_net_send_preinit(instance) != 0) {
112 				instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_CANT_ALLOCATE_MSG_BUFFER;
113 				instance->schedule_disconnect = 1;
114 			}
115 		} else {
116 			qdevice_log(LOG_CRIT, "Unhandled nss_sock_non_blocking_client_succeeded");
117 			exit(1);
118 		}
119 	} else {
120 		if (qdevice_net_socket_write(instance) == -1) {
121 			instance->schedule_disconnect = 1;
122 		}
123 	}
124 }
125 
126 static void
qdevice_net_poll_err_socket(struct qdevice_net_instance * instance,const PRPollDesc * pfd)127 qdevice_net_poll_err_socket(struct qdevice_net_instance *instance, const PRPollDesc *pfd)
128 {
129 
130 	if (instance->state == QDEVICE_NET_INSTANCE_STATE_WAITING_CONNECT) {
131 		/*
132 		 * Workaround for RHEL<7. Pollout is never set for nonblocking connect (doesn't work
133 		 * only with poll, select works as expected!???).
134 		 * So test if client is still valid and if pollout was not already called (ensured
135 		 * by default because of order in PR_Poll).
136 		 * If both applies it's possible to emulate pollout set by calling poll_write.
137 		 */
138 		if (!instance->non_blocking_client.destroyed) {
139 			qdevice_net_poll_write_socket(instance, pfd);
140 		}
141 	} else {
142 		qdevice_log(LOG_ERR, "POLL_ERR (%u) on main socket", pfd->out_flags);
143 
144 		instance->schedule_disconnect = 1;
145 		instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_SERVER_CLOSED_CONNECTION;
146 	}
147 }
148 
149 static void
qdevice_net_poll_read_heuristics_log(struct qdevice_net_instance * instance)150 qdevice_net_poll_read_heuristics_log(struct qdevice_net_instance *instance)
151 {
152 	int res;
153 
154 	res = qdevice_heuristics_log_read_from_pipe(&instance->qdevice_instance_ptr->heuristics_instance);
155 	if (res == -1) {
156 		instance->schedule_disconnect = 1;
157 		instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_HEURISTICS_WORKER_CLOSED;
158 	}
159 }
160 
161 static void
qdevice_net_poll_read_heuristics_cmd(struct qdevice_net_instance * instance)162 qdevice_net_poll_read_heuristics_cmd(struct qdevice_net_instance *instance)
163 {
164 	int res;
165 
166 	res = qdevice_heuristics_cmd_read_from_pipe(&instance->qdevice_instance_ptr->heuristics_instance);
167 	if (res == -1) {
168 		instance->schedule_disconnect = 1;
169 		instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_HEURISTICS_WORKER_CLOSED;
170 	}
171 }
172 
173 static void
qdevice_net_poll_write_heuristics_cmd(struct qdevice_net_instance * instance)174 qdevice_net_poll_write_heuristics_cmd(struct qdevice_net_instance *instance)
175 {
176 	int res;
177 
178 	res = qdevice_heuristics_cmd_write(&instance->qdevice_instance_ptr->heuristics_instance);
179 	if (res == -1) {
180 		instance->schedule_disconnect = 1;
181 		instance->disconnect_reason =
182 		    QDEVICE_NET_DISCONNECT_REASON_HEURISTICS_CANT_SEND_RECEIVE_MSG;
183 	}
184 }
185 
186 static void
qdevice_net_poll_read_ipc_socket(struct qdevice_net_instance * instance)187 qdevice_net_poll_read_ipc_socket(struct qdevice_net_instance *instance)
188 {
189 	struct unix_socket_client *client;
190 	PRFileDesc *prfd;
191 	struct qdevice_ipc_user_data *user_data;
192 
193 	if (qdevice_ipc_accept(instance->qdevice_instance_ptr, &client) != 0) {
194 		return ;
195 	}
196 
197 	prfd = PR_CreateSocketPollFd(client->socket);
198 	if (prfd == NULL) {
199 		qdevice_log_nss(LOG_CRIT, "Can't create NSPR poll fd for IPC client. "
200 		    "Disconnecting client");
201 		qdevice_ipc_client_disconnect(instance->qdevice_instance_ptr, client);
202 
203 		return ;
204 	}
205 
206 	user_data = (struct qdevice_ipc_user_data *)client->user_data;
207 	user_data->model_data = (void *)prfd;
208 }
209 
210 static PRPollDesc *
qdevice_net_pr_poll_array_create(struct qdevice_net_instance * instance)211 qdevice_net_pr_poll_array_create(struct qdevice_net_instance *instance)
212 {
213 	struct pr_poll_array *poll_array;
214 	PRPollDesc *poll_desc;
215 	struct qdevice_net_poll_array_user_data *user_data;
216 	struct unix_socket_client *ipc_client;
217 	const struct unix_socket_client_list *ipc_client_list;
218 	struct qdevice_ipc_user_data *qdevice_ipc_user_data;
219 
220 	poll_array = &instance->poll_array;
221 	ipc_client_list = &instance->qdevice_instance_ptr->local_ipc.clients;
222 
223 	if (qdevice_ipc_is_closed(instance->qdevice_instance_ptr)) {
224 		qdevice_log(LOG_DEBUG, "Local socket is closed");
225 		instance->schedule_disconnect = 1;
226 		instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_LOCAL_SOCKET_CLOSED;
227 
228 		return (NULL);
229 	}
230 
231 	pr_poll_array_clean(poll_array);
232 
233 	if (pr_poll_array_add(poll_array, &poll_desc, (void **)&user_data) < 0) {
234 		return (NULL);
235 	}
236 	poll_desc->fd = instance->votequorum_poll_fd;
237 	poll_desc->in_flags = PR_POLL_READ;
238 	user_data->type = QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_VOTEQUORUM;
239 
240 	if (!instance->qdevice_instance_ptr->sync_in_progress) {
241 		if (pr_poll_array_add(poll_array, &poll_desc, (void **)&user_data) < 0) {
242 			return (NULL);
243 		}
244 		poll_desc->fd = instance->cmap_poll_fd;
245 		poll_desc->in_flags = PR_POLL_READ;
246 		user_data->type = QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_CMAP;
247 	}
248 
249 	if (pr_poll_array_add(poll_array, &poll_desc, (void **)&user_data) < 0) {
250 		return (NULL);
251 	}
252 	poll_desc->fd = instance->ipc_socket_poll_fd;
253 	poll_desc->in_flags = PR_POLL_READ;
254 	user_data->type = QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_IPC_SOCKET;
255 
256 	if (pr_poll_array_add(poll_array, &poll_desc, (void **)&user_data) < 0) {
257 		return (NULL);
258 	}
259 
260 	poll_desc->fd = instance->heuristics_pipe_log_recv_poll_fd;
261 	poll_desc->in_flags = PR_POLL_READ;
262 	user_data->type = QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_HEURISTICS_LOG_RECV;
263 
264 	if (pr_poll_array_add(poll_array, &poll_desc, (void **)&user_data) < 0) {
265 		return (NULL);
266 	}
267 
268 	poll_desc->fd = instance->heuristics_pipe_cmd_recv_poll_fd;
269 	poll_desc->in_flags = PR_POLL_READ;
270 	user_data->type = QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_HEURISTICS_CMD_RECV;
271 
272 	if (pr_poll_array_add(poll_array, &poll_desc, (void **)&user_data) < 0) {
273 		return (NULL);
274 	}
275 
276 	if (!send_buffer_list_empty(
277 	    &instance->qdevice_instance_ptr->heuristics_instance.cmd_out_buffer_list)) {
278 		poll_desc->fd = instance->heuristics_pipe_cmd_send_poll_fd;
279 		poll_desc->in_flags = PR_POLL_WRITE;
280 		user_data->type = QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_HEURISTICS_CMD_SEND;
281 
282 		if (pr_poll_array_add(poll_array, &poll_desc, (void **)&user_data) < 0) {
283 			return (NULL);
284 		}
285 	}
286 
287 	if (instance->state != QDEVICE_NET_INSTANCE_STATE_WAITING_CONNECT ||
288 	    !instance->non_blocking_client.destroyed) {
289 		if (pr_poll_array_add(poll_array, &poll_desc, (void **)&user_data) < 0) {
290 			return (NULL);
291 		}
292 
293 		user_data->type = QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_SOCKET;
294 
295 		if (instance->state == QDEVICE_NET_INSTANCE_STATE_WAITING_CONNECT) {
296 			poll_desc->fd = instance->non_blocking_client.socket;
297 			poll_desc->in_flags = PR_POLL_WRITE | PR_POLL_EXCEPT;
298 		} else {
299 			poll_desc->fd = instance->socket;
300 			poll_desc->in_flags = PR_POLL_READ;
301 
302 			if (!send_buffer_list_empty(&instance->send_buffer_list)) {
303 				poll_desc->in_flags |= PR_POLL_WRITE;
304 			}
305 		}
306 	}
307 
308 	TAILQ_FOREACH(ipc_client, ipc_client_list, entries) {
309 		if (!ipc_client->reading_line && !ipc_client->writing_buffer) {
310 			continue;
311 		}
312 
313 		if (pr_poll_array_add(poll_array, &poll_desc, (void **)&user_data) < 0) {
314 			return (NULL);
315 		}
316 
317 		qdevice_ipc_user_data = (struct qdevice_ipc_user_data *)ipc_client->user_data;
318 		poll_desc->fd = (PRFileDesc *)qdevice_ipc_user_data->model_data;
319 		if (ipc_client->reading_line) {
320 			poll_desc->in_flags |= PR_POLL_READ;
321 		}
322 
323 		if (ipc_client->writing_buffer) {
324 			poll_desc->in_flags |= PR_POLL_WRITE;
325 		}
326 
327 		user_data->type = QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_IPC_CLIENT;
328 		user_data->ipc_client = ipc_client;
329 	}
330 
331 	pr_poll_array_gc(poll_array);
332 
333 	return (poll_array->array);
334 }
335 
336 int
qdevice_net_poll(struct qdevice_net_instance * instance)337 qdevice_net_poll(struct qdevice_net_instance *instance)
338 {
339 	PRPollDesc *pfds;
340 	PRFileDesc *prfd;
341 	PRInt32 poll_res;
342 	ssize_t i;
343 	struct qdevice_net_poll_array_user_data *user_data;
344 	struct unix_socket_client *ipc_client;
345 	struct qdevice_ipc_user_data *qdevice_ipc_user_data;
346 	int case_processed;
347 
348 	pfds = qdevice_net_pr_poll_array_create(instance);
349 	if (pfds == NULL) {
350 		return (-1);
351 	}
352 
353 	instance->schedule_disconnect = 0;
354 
355 	if ((poll_res = PR_Poll(pfds, pr_poll_array_size(&instance->poll_array),
356 	    timer_list_time_to_expire(&instance->main_timer_list))) > 0) {
357 		for (i = 0; i < pr_poll_array_size(&instance->poll_array); i++) {
358 			user_data = pr_poll_array_get_user_data(&instance->poll_array, i);
359 
360 			ipc_client = user_data->ipc_client;
361 
362 			if (pfds[i].out_flags & PR_POLL_READ) {
363 				case_processed = 0;
364 
365 				switch (user_data->type) {
366 				case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_SOCKET:
367 					case_processed = 1;
368 					qdevice_net_poll_read_socket(instance);
369 					break;
370 				case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_VOTEQUORUM:
371 					case_processed = 1;
372 					qdevice_net_poll_read_votequorum(instance);
373 					break;
374 				case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_CMAP:
375 					case_processed = 1;
376 					qdevice_net_poll_read_cmap(instance);
377 					break;
378 				case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_IPC_SOCKET:
379 					case_processed = 1;
380 					qdevice_net_poll_read_ipc_socket(instance);
381 					break;
382 				case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_IPC_CLIENT:
383 					case_processed = 1;
384 					qdevice_ipc_io_read(instance->qdevice_instance_ptr, ipc_client);
385 					break;
386 				case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_HEURISTICS_CMD_SEND:
387 					/*
388 					 * Read on heuristics cmd send fd shouldn't happen
389 					 */
390 					break;
391 				case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_HEURISTICS_CMD_RECV:
392 					case_processed = 1;
393 					qdevice_net_poll_read_heuristics_cmd(instance);
394 					break;
395 				case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_HEURISTICS_LOG_RECV:
396 					case_processed = 1;
397 					qdevice_net_poll_read_heuristics_log(instance);
398 					break;
399 				/*
400 				 * Default is not defined intentionally. Compiler shows warning when
401 				 * new poll_array_user_data_type is added
402 				 */
403 				}
404 
405 				if (!case_processed) {
406 					qdevice_log(LOG_CRIT, "Unhandled read on poll descriptor %u", i);
407 					exit(1);
408 				}
409 			}
410 
411 			if (!instance->schedule_disconnect && pfds[i].out_flags & PR_POLL_WRITE) {
412 				case_processed = 0;
413 
414 				switch (user_data->type) {
415 				case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_SOCKET:
416 					case_processed = 1;
417 					qdevice_net_poll_write_socket(instance, &pfds[i]);
418 					break;
419 				case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_IPC_CLIENT:
420 					case_processed = 1;
421 					qdevice_ipc_io_write(instance->qdevice_instance_ptr, ipc_client);
422 					break;
423 				case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_HEURISTICS_CMD_SEND:
424 					case_processed = 1;
425 					qdevice_net_poll_write_heuristics_cmd(instance);
426 					break;
427 				case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_VOTEQUORUM:
428 				case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_CMAP:
429 				case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_IPC_SOCKET:
430 				case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_HEURISTICS_CMD_RECV:
431 				case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_HEURISTICS_LOG_RECV:
432 					/*
433 					 * Write on votequorum, cmap, ipc socket and
434 					 * heuristics log shouldn't happen.
435 					 */
436 					break;
437 				/*
438 				 * Default is not defined intentionally. Compiler shows warning when
439 				 * new poll_array_user_data_type is added
440 				 */
441 				}
442 
443 				if (!case_processed) {
444 					qdevice_log(LOG_CRIT, "Unhandled write on poll descriptor %u", i);
445 					exit(1);
446 				}
447 			}
448 
449 			if (!instance->schedule_disconnect &&
450 			    (pfds[i].out_flags & (PR_POLL_ERR|PR_POLL_NVAL|PR_POLL_HUP|PR_POLL_EXCEPT)) &&
451 			    !(pfds[i].out_flags & (PR_POLL_READ|PR_POLL_WRITE))) {
452 				case_processed = 0;
453 
454 				switch (user_data->type) {
455 				case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_SOCKET:
456 					case_processed = 1;
457 					qdevice_net_poll_err_socket(instance, &pfds[i]);
458 					break;
459 				case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_IPC_SOCKET:
460 					case_processed = 1;
461 					if (pfds[i].out_flags != PR_POLL_NVAL) {
462 						qdevice_log(LOG_CRIT, "POLLERR (%u) on local socket",
463 						    pfds[i].out_flags);
464 						exit(1);
465 					} else {
466 						qdevice_log(LOG_DEBUG, "Local socket is closed");
467 						instance->schedule_disconnect = 1;
468 						instance->disconnect_reason =
469 						    QDEVICE_NET_DISCONNECT_REASON_LOCAL_SOCKET_CLOSED;
470 					}
471 					break;
472 				case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_IPC_CLIENT:
473 					case_processed = 1;
474 					qdevice_log(LOG_DEBUG, "POLL_ERR (%u) on ipc client socket. "
475 					    "Disconnecting.",  pfds[i].out_flags);
476 					ipc_client->schedule_disconnect = 1;
477 					break;
478 				case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_VOTEQUORUM:
479 				case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_CMAP:
480 					case_processed = 1;
481 					qdevice_log(LOG_DEBUG, "POLL_ERR (%u) on corosync socket. "
482 					    "Disconnecting.",  pfds[i].out_flags);
483 
484 					instance->schedule_disconnect = 1;
485 					instance->disconnect_reason =
486 						QDEVICE_NET_DISCONNECT_REASON_COROSYNC_CONNECTION_CLOSED;
487 					break;
488 				case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_HEURISTICS_LOG_RECV:
489 				case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_HEURISTICS_CMD_RECV:
490 				case QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_HEURISTICS_CMD_SEND:
491 					case_processed = 1;
492 
493 					/*
494 					 * Closed pipe doesn't mean return of PR_POLL_READ. To display
495 					 * better log message, we call read log as if POLL_READ would
496 					 * be set.
497 					 */
498 					qdevice_net_poll_read_heuristics_log(instance);
499 
500 					qdevice_log(LOG_DEBUG, "POLL_ERR (%u) on heuristics pipe. "
501 					    "Disconnecting.",  pfds[i].out_flags);
502 
503 					instance->schedule_disconnect = 1;
504 					instance->disconnect_reason =
505 						QDEVICE_NET_DISCONNECT_REASON_HEURISTICS_WORKER_CLOSED;
506 					break;
507 				/*
508 				 * Default is not defined intentionally. Compiler shows warning when
509 				 * new poll_array_user_data_type is added
510 				 */
511 				}
512 
513 				if (!case_processed) {
514 					qdevice_log(LOG_CRIT, "Unhandled error on poll descriptor %u", i);
515 					exit(1);
516 				}
517 			}
518 
519 			if (user_data->type == QDEVICE_NET_POLL_ARRAY_USER_DATA_TYPE_IPC_CLIENT &&
520 			    ipc_client->schedule_disconnect) {
521 				qdevice_ipc_user_data = (struct qdevice_ipc_user_data *)ipc_client->user_data;
522 				prfd = (PRFileDesc *)qdevice_ipc_user_data->model_data;
523 
524 				if (PR_DestroySocketPollFd(prfd) != PR_SUCCESS) {
525 					qdevice_log_nss(LOG_WARNING, "Unable to destroy client IPC poll socket fd");
526 				}
527 
528 				qdevice_ipc_client_disconnect(instance->qdevice_instance_ptr, ipc_client);
529 			}
530 		}
531 	}
532 
533 	if (!instance->schedule_disconnect) {
534 		timer_list_expire(&instance->main_timer_list);
535 	}
536 
537 	if (instance->schedule_disconnect) {
538 		/*
539 		 * Schedule disconnect can be set by this function, by some timer_list callback
540 		 * or cmap/votequorum callbacks
541 		 */
542 		return (-1);
543 	}
544 
545 	return (0);
546 }
547