2 * sslproc.c: An interface to ssld
3 * Copyright (C) 2007 Aaron Sethman <androsyn@ratbox.org>
4 * Copyright (C) 2007 ircd-ratbox development team
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
24 #include <ratbox_lib.h>
39 #define ZIPSTATS_TIME 60
41 static void collect_zipstats(void *unused
);
42 static void ssl_read_ctl(rb_fde_t
* F
, void *data
);
43 static int ssld_count
;
45 static char tmpbuf
[READBUF_SIZE
];
46 static char nul
= '\0';
50 typedef struct _ssl_ctl_buf
55 rb_fde_t
*F
[MAXPASSFD
];
72 static void send_new_ssl_certs_one(ssl_ctl_t
* ctl
, const char *ssl_cert
,
73 const char *ssl_private_key
, const char *ssl_dh_params
,
74 const char *ssl_cipher_list
);
75 static void send_init_prng(ssl_ctl_t
* ctl
, prng_seed_t seedtype
, const char *path
);
76 static void send_certfp_method(ssl_ctl_t
*ctl
, int method
);
79 static rb_dlink_list ssl_daemons
;
81 static inline uint32_t
82 buf_to_uint32(char *buf
)
85 memcpy(&x
, buf
, sizeof(x
));
90 uint32_to_buf(char *buf
, uint32_t x
)
92 memcpy(buf
, &x
, sizeof(x
));
97 allocate_ssl_daemon(rb_fde_t
* F
, rb_fde_t
* P
, int pid
)
101 if(F
== NULL
|| pid
< 0)
103 ctl
= rb_malloc(sizeof(ssl_ctl_t
));
108 rb_dlinkAdd(ctl
, &ctl
->node
, &ssl_daemons
);
113 free_ssl_daemon(ssl_ctl_t
* ctl
)
116 ssl_ctl_buf_t
*ctl_buf
;
121 RB_DLINK_FOREACH(ptr
, ctl
->readq
.head
)
124 for(x
= 0; x
< ctl_buf
->nfds
; x
++)
125 rb_close(ctl_buf
->F
[x
]);
127 rb_free(ctl_buf
->buf
);
131 RB_DLINK_FOREACH(ptr
, ctl
->writeq
.head
)
134 for(x
= 0; x
< ctl_buf
->nfds
; x
++)
135 rb_close(ctl_buf
->F
[x
]);
137 rb_free(ctl_buf
->buf
);
142 rb_dlinkDelete(&ctl
->node
, &ssl_daemons
);
146 static char *ssld_path
;
148 static int ssld_spin_count
= 0;
149 static time_t last_spin
;
150 static int ssld_wait
= 0;
156 rb_dlink_node
*ptr
, *next
;
158 RB_DLINK_FOREACH_SAFE(ptr
, next
, ssl_daemons
.head
)
165 rb_kill(ctl
->pid
, SIGKILL
);
170 ssl_dead(ssl_ctl_t
* ctl
)
177 rb_kill(ctl
->pid
, SIGKILL
); /* make sure the process is really gone */
178 ilog(L_MAIN
, "ssld helper died - attempting to restart");
179 sendto_realops_snomask(SNO_GENERAL
, L_ALL
, "ssld helper died - attempting to restart");
180 start_ssldaemon(1, ServerInfo
.ssl_cert
, ServerInfo
.ssl_private_key
, ServerInfo
.ssl_dh_params
, ServerInfo
.ssl_cipher_list
);
184 ssl_do_pipe(rb_fde_t
* F
, void *data
)
187 ssl_ctl_t
*ctl
= data
;
188 retlen
= rb_write(F
, "0", 1);
189 if(retlen
== 0 || (retlen
< 0 && !rb_ignore_errno(errno
)))
194 rb_setselect(F
, RB_SELECT_READ
, ssl_do_pipe
, data
);
198 restart_ssld_event(void *unused
)
203 if(ServerInfo
.ssld_count
> get_ssld_count())
205 int start
= ServerInfo
.ssld_count
- get_ssld_count();
206 ilog(L_MAIN
, "Attempting to restart ssld processes");
207 sendto_realops_snomask(SNO_GENERAL
, L_ALL
, "Attempt to restart ssld processes");
208 start_ssldaemon(start
, ServerInfo
.ssl_cert
, ServerInfo
.ssl_private_key
, ServerInfo
.ssl_dh_params
, ServerInfo
.ssl_cipher_list
);
213 start_ssldaemon(int count
, const char *ssl_cert
, const char *ssl_private_key
, const char *ssl_dh_params
, const char *ssl_cipher_list
)
218 const char *suffix
= ".exe";
220 const char *suffix
= "";
223 char fullpath
[PATH_MAX
+ 1];
234 if(ssld_spin_count
> 20 && (rb_current_time() - last_spin
< 5))
236 ilog(L_MAIN
, "ssld helper is spinning - will attempt to restart in 1 minute");
237 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
238 "ssld helper is spinning - will attempt to restart in 1 minute");
239 rb_event_add("restart_ssld_event", restart_ssld_event
, NULL
, 60);
245 last_spin
= rb_current_time();
247 if(ssld_path
== NULL
)
249 rb_snprintf(fullpath
, sizeof(fullpath
), "%s/ssld%s", PKGLIBEXECDIR
, suffix
);
251 if(access(fullpath
, X_OK
) == -1)
253 rb_snprintf(fullpath
, sizeof(fullpath
), "%s/bin/ssld%s",
254 ConfigFileEntry
.dpath
, suffix
);
255 if(access(fullpath
, X_OK
) == -1)
258 "Unable to execute ssld%s in %s or %s/bin",
259 suffix
, PKGLIBEXECDIR
, ConfigFileEntry
.dpath
);
263 ssld_path
= rb_strdup(fullpath
);
265 rb_strlcpy(buf
, "-ircd ssld daemon helper", sizeof(buf
));
269 for(i
= 0; i
< count
; i
++)
272 if(rb_socketpair(AF_UNIX
, SOCK_DGRAM
, 0, &F1
, &F2
, "SSL/TLS handle passing socket") == -1)
274 ilog(L_MAIN
, "Unable to create ssld - rb_socketpair failed: %s", strerror(errno
));
278 rb_set_buffers(F1
, READBUF_SIZE
);
279 rb_set_buffers(F2
, READBUF_SIZE
);
280 rb_snprintf(fdarg
, sizeof(fdarg
), "%d", rb_get_fd(F2
));
281 rb_setenv("CTL_FD", fdarg
, 1);
282 if(rb_pipe(&P1
, &P2
, "SSL/TLS pipe") == -1)
284 ilog(L_MAIN
, "Unable to create ssld - rb_pipe failed: %s", strerror(errno
));
287 rb_snprintf(fdarg
, sizeof(fdarg
), "%d", rb_get_fd(P1
));
288 rb_setenv("CTL_PIPE", fdarg
, 1);
289 rb_snprintf(s_pid
, sizeof(s_pid
), "%d", (int)getpid());
290 rb_setenv("CTL_PPID", s_pid
, 1);
292 SetHandleInformation((HANDLE
) rb_get_fd(F2
), HANDLE_FLAG_INHERIT
, 1);
293 SetHandleInformation((HANDLE
) rb_get_fd(P1
), HANDLE_FLAG_INHERIT
, 1);
296 pid
= rb_spawn_process(ssld_path
, (const char **) parv
);
299 ilog(L_MAIN
, "Unable to create ssld: %s\n", strerror(errno
));
309 ctl
= allocate_ssl_daemon(F1
, P2
, pid
);
312 send_init_prng(ctl
, RB_PRNG_DEFAULT
, NULL
);
313 send_certfp_method(ctl
, ConfigFileEntry
.certfp_method
);
315 if(ssl_cert
!= NULL
&& ssl_private_key
!= NULL
)
316 send_new_ssl_certs_one(ctl
, ssl_cert
, ssl_private_key
,
317 ssl_dh_params
!= NULL
? ssl_dh_params
: "",
318 ssl_cipher_list
!= NULL
? ssl_cipher_list
: "");
320 ssl_read_ctl(ctl
->F
, ctl
);
321 ssl_do_pipe(P2
, ctl
);
328 ssl_process_zipstats(ssl_ctl_t
* ctl
, ssl_ctl_buf_t
* ctl_buf
)
330 struct Client
*server
;
331 struct ZipStats
*zips
;
333 (void) rb_string_to_array(ctl_buf
->buf
, parv
, 6);
334 server
= find_server(NULL
, parv
[1]);
335 if(server
== NULL
|| server
->localClient
== NULL
|| !IsCapable(server
, CAP_ZIP
))
337 if(server
->localClient
->zipstats
== NULL
)
338 server
->localClient
->zipstats
= rb_malloc(sizeof(struct ZipStats
));
340 zips
= server
->localClient
->zipstats
;
342 zips
->in
+= strtoull(parv
[2], NULL
, 10);
343 zips
->in_wire
+= strtoull(parv
[3], NULL
, 10);
344 zips
->out
+= strtoull(parv
[4], NULL
, 10);
345 zips
->out_wire
+= strtoull(parv
[5], NULL
, 10);
348 zips
->in_ratio
= ((double) (zips
->in
- zips
->in_wire
) / (double) zips
->in
) * 100.00;
353 zips
->out_ratio
= ((double) (zips
->out
- zips
->out_wire
) / (double) zips
->out
) * 100.00;
359 ssl_process_dead_fd(ssl_ctl_t
* ctl
, ssl_ctl_buf_t
* ctl_buf
)
361 struct Client
*client_p
;
365 if(ctl_buf
->buflen
< 6)
366 return; /* bogus message..drop it.. XXX should warn here */
368 fd
= buf_to_uint32(&ctl_buf
->buf
[1]);
369 rb_strlcpy(reason
, &ctl_buf
->buf
[5], sizeof(reason
));
370 client_p
= find_cli_connid_hash(fd
);
373 if(IsAnyServer(client_p
) || IsRegistered(client_p
))
375 /* read any last moment ERROR, QUIT or the like -- jilles */
376 if (!strcmp(reason
, "Remote host closed the connection"))
377 read_packet(client_p
->localClient
->F
, client_p
);
378 if (IsAnyDead(client_p
))
381 if(IsAnyServer(client_p
))
383 sendto_realops_snomask(SNO_GENERAL
, is_remote_connect(client_p
) && !IsServer(client_p
) ? L_NETWIDE
: L_ALL
, "ssld error for %s: %s", client_p
->name
, reason
);
384 ilog(L_SERVER
, "ssld error for %s: %s", log_client_name(client_p
, SHOW_IP
), reason
);
386 exit_client(client_p
, client_p
, &me
, reason
);
391 ssl_process_cipher_string(ssl_ctl_t
*ctl
, ssl_ctl_buf_t
*ctl_buf
)
393 struct Client
*client_p
;
397 if(ctl_buf
->buflen
< 6)
398 return; /* bogus message..drop it.. XXX should warn here */
400 fd
= buf_to_uint32(&ctl_buf
->buf
[1]);
401 cstring
= (const char *)&ctl_buf
->buf
[5];
403 if(EmptyString(cstring
))
406 client_p
= find_cli_connid_hash(fd
);
407 if(client_p
!= NULL
&& client_p
->localClient
!= NULL
)
409 rb_free(client_p
->localClient
->cipher_string
);
410 client_p
->localClient
->cipher_string
= rb_strdup(cstring
);
416 ssl_process_certfp(ssl_ctl_t
* ctl
, ssl_ctl_buf_t
* ctl_buf
)
418 struct Client
*client_p
;
425 if(ctl_buf
->buflen
> 5 + RB_SSL_CERTFP_LEN
)
426 return; /* bogus message..drop it.. XXX should warn here */
428 fd
= buf_to_uint32(&ctl_buf
->buf
[1]);
429 len
= buf_to_uint32(&ctl_buf
->buf
[5]);
430 certfp
= (uint8_t *)&ctl_buf
->buf
[9];
431 client_p
= find_cli_connid_hash(fd
);
434 rb_free(client_p
->certfp
);
435 certfp_string
= rb_malloc(len
* 2 + 1);
436 for(i
= 0; i
< len
; i
++)
437 rb_snprintf(certfp_string
+ 2 * i
, 3, "%02x",
439 client_p
->certfp
= certfp_string
;
443 ssl_process_cmd_recv(ssl_ctl_t
* ctl
)
445 static const char *cannot_setup_ssl
= "ssld cannot setup ssl, check your certificates and private key";
446 static const char *no_ssl_or_zlib
= "ssld has neither SSL/TLS or zlib support killing all sslds";
447 rb_dlink_node
*ptr
, *next
;
448 ssl_ctl_buf_t
*ctl_buf
;
451 RB_DLINK_FOREACH_SAFE(ptr
, next
, ctl
->readq
.head
)
454 switch (*ctl_buf
->buf
)
457 ssl_ok
= 0; /* ssld says it can't do ssl/tls */
460 ssl_process_dead_fd(ctl
, ctl_buf
);
463 ssl_process_cipher_string(ctl
, ctl_buf
);
466 ssl_process_certfp(ctl
, ctl_buf
);
469 ssl_process_zipstats(ctl
, ctl_buf
);
473 ilog(L_MAIN
, "%s", cannot_setup_ssl
);
474 sendto_realops_snomask(SNO_GENERAL
, L_ALL
, "%s", cannot_setup_ssl
);
479 ilog(L_MAIN
, "%s", no_ssl_or_zlib
);
480 sendto_realops_snomask(SNO_GENERAL
, L_ALL
, "%s", no_ssl_or_zlib
);
487 ilog(L_MAIN
, "Received invalid command from ssld: %s", ctl_buf
->buf
);
488 sendto_realops_snomask(SNO_GENERAL
, L_ALL
, "Received invalid command from ssld");
491 rb_dlinkDelete(ptr
, &ctl
->readq
);
492 rb_free(ctl_buf
->buf
);
500 ssl_read_ctl(rb_fde_t
* F
, void *data
)
502 ssl_ctl_buf_t
*ctl_buf
;
503 ssl_ctl_t
*ctl
= data
;
510 ctl_buf
= rb_malloc(sizeof(ssl_ctl_buf_t
));
511 ctl_buf
->buf
= rb_malloc(READSIZE
);
512 retlen
= rb_recv_fd_buf(ctl
->F
, ctl_buf
->buf
, READSIZE
, ctl_buf
->F
, 4);
513 ctl_buf
->buflen
= retlen
;
516 rb_free(ctl_buf
->buf
);
520 rb_dlinkAddTail(ctl_buf
, &ctl_buf
->node
, &ctl
->readq
);
524 if(retlen
== 0 || (retlen
< 0 && !rb_ignore_errno(errno
)))
529 ssl_process_cmd_recv(ctl
);
530 rb_setselect(ctl
->F
, RB_SELECT_READ
, ssl_read_ctl
, ctl
);
536 ssl_ctl_t
*ctl
, *lowest
= NULL
;
539 RB_DLINK_FOREACH(ptr
, ssl_daemons
.head
)
549 if(ctl
->cli_count
< lowest
->cli_count
)
556 ssl_write_ctl(rb_fde_t
* F
, void *data
)
558 ssl_ctl_t
*ctl
= data
;
559 ssl_ctl_buf_t
*ctl_buf
;
560 rb_dlink_node
*ptr
, *next
;
566 RB_DLINK_FOREACH_SAFE(ptr
, next
, ctl
->writeq
.head
)
569 /* in theory unix sock_dgram shouldn't ever short write this.. */
570 retlen
= rb_send_fd_buf(ctl
->F
, ctl_buf
->F
, ctl_buf
->nfds
, ctl_buf
->buf
, ctl_buf
->buflen
, ctl
->pid
);
573 rb_dlinkDelete(ptr
, &ctl
->writeq
);
574 for(x
= 0; x
< ctl_buf
->nfds
; x
++)
575 rb_close(ctl_buf
->F
[x
]);
576 rb_free(ctl_buf
->buf
);
580 if(retlen
== 0 || (retlen
< 0 && !rb_ignore_errno(errno
)))
587 rb_setselect(ctl
->F
, RB_SELECT_WRITE
, ssl_write_ctl
, ctl
);
593 ssl_cmd_write_queue(ssl_ctl_t
* ctl
, rb_fde_t
** F
, int count
, const void *buf
, size_t buflen
)
595 ssl_ctl_buf_t
*ctl_buf
;
602 ctl_buf
= rb_malloc(sizeof(ssl_ctl_buf_t
));
603 ctl_buf
->buf
= rb_malloc(buflen
);
604 memcpy(ctl_buf
->buf
, buf
, buflen
);
605 ctl_buf
->buflen
= buflen
;
607 for(x
= 0; x
< count
&& x
< MAXPASSFD
; x
++)
609 ctl_buf
->F
[x
] = F
[x
];
611 ctl_buf
->nfds
= count
;
612 rb_dlinkAddTail(ctl_buf
, &ctl_buf
->node
, &ctl
->writeq
);
613 ssl_write_ctl(ctl
->F
, ctl
);
618 send_new_ssl_certs_one(ssl_ctl_t
* ctl
, const char *ssl_cert
, const char *ssl_private_key
, const char *ssl_dh_params
, const char *ssl_cipher_list
)
622 len
= strlen(ssl_cert
) + strlen(ssl_private_key
) + strlen(ssl_dh_params
) + 5;
623 if(len
> sizeof(tmpbuf
))
625 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
626 "Parameters for send_new_ssl_certs_one too long (%zu > %zu) to pass to ssld, not sending...",
627 len
, sizeof(tmpbuf
));
629 "Parameters for send_new_ssl_certs_one too long (%zu > %zu) to pass to ssld, not sending...",
630 len
, sizeof(tmpbuf
));
633 len
= rb_snprintf(tmpbuf
, sizeof(tmpbuf
), "K%c%s%c%s%c%s%c%s%c", nul
, ssl_cert
, nul
,
634 ssl_private_key
, nul
, ssl_dh_params
, nul
,
635 ssl_cipher_list
!= NULL
? ssl_cipher_list
: "", nul
);
636 ssl_cmd_write_queue(ctl
, NULL
, 0, tmpbuf
, len
);
640 send_init_prng(ssl_ctl_t
* ctl
, prng_seed_t seedtype
, const char *path
)
644 uint8_t seed
= (uint8_t) seedtype
;
652 if(len
> sizeof(tmpbuf
))
654 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
655 "Parameters for send_init_prng too long (%zd > %zd) to pass to ssld, not sending...",
656 len
, sizeof(tmpbuf
));
658 "Parameters for send_init_prng too long (%zd > %zd) to pass to ssld, not sending...",
659 len
, sizeof(tmpbuf
));
663 len
= rb_snprintf(tmpbuf
, sizeof(tmpbuf
), "I%c%s%c", seed
, s
, nul
);
664 ssl_cmd_write_queue(ctl
, NULL
, 0, tmpbuf
, len
);
668 send_certfp_method(ssl_ctl_t
*ctl
, int method
)
673 uint32_to_buf(&buf
[1], method
);
674 ssl_cmd_write_queue(ctl
, NULL
, 0, buf
, sizeof(buf
));
678 send_new_ssl_certs(const char *ssl_cert
, const char *ssl_private_key
, const char *ssl_dh_params
, const char *ssl_cipher_list
)
681 if(ssl_cert
== NULL
|| ssl_private_key
== NULL
|| ssl_dh_params
== NULL
)
686 RB_DLINK_FOREACH(ptr
, ssl_daemons
.head
)
688 ssl_ctl_t
*ctl
= ptr
->data
;
689 send_new_ssl_certs_one(ctl
, ssl_cert
, ssl_private_key
, ssl_dh_params
, ssl_cipher_list
);
695 start_ssld_accept(rb_fde_t
* sslF
, rb_fde_t
* plainF
, uint32_t id
)
704 uint32_to_buf(&buf
[1], id
);
707 ssl_cmd_write_queue(ctl
, F
, 2, buf
, sizeof(buf
));
712 start_ssld_connect(rb_fde_t
* sslF
, rb_fde_t
* plainF
, uint32_t id
)
721 uint32_to_buf(&buf
[1], id
);
725 ssl_cmd_write_queue(ctl
, F
, 2, buf
, sizeof(buf
));
730 ssld_decrement_clicount(ssl_ctl_t
* ctl
)
736 if(ctl
->dead
&& !ctl
->cli_count
)
738 free_ssl_daemon(ctl
);
743 * what we end up sending to the ssld process for ziplinks is the following
744 * Z[ourfd][level][RECVQ]
745 * Z = ziplinks command = buf[0]
746 * ourfd = Our end of the socketpair = buf[1..4]
747 * level = zip level buf[5]
748 * recvqlen = our recvq len = buf[6-7]
749 * recvq = any data we read prior to starting ziplinks
752 start_zlib_session(void *data
)
754 struct Client
*server
= (struct Client
*) data
;
765 size_t hdr
= (sizeof(uint8_t) * 2) + sizeof(uint32_t);
769 server
->localClient
->event
= NULL
;
771 recvqlen
= rb_linebuf_len(&server
->localClient
->buf_recvq
);
773 len
= recvqlen
+ hdr
;
775 if(len
> READBUF_SIZE
)
777 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
778 "ssld - attempted to pass message of %zd len, max len %d, giving up",
780 ilog(L_MAIN
, "ssld - attempted to pass message of %zd len, max len %d, giving up", len
, READBUF_SIZE
);
781 exit_client(server
, server
, server
, "ssld readbuf exceeded");
785 buf
= rb_malloc(len
);
786 level
= ConfigFileEntry
.compression_level
;
788 uint32_to_buf(&buf
[1], rb_get_fd(server
->localClient
->F
));
789 buf
[5] = (char) level
;
791 recvq_start
= &buf
[6];
792 server
->localClient
->zipstats
= rb_malloc(sizeof(struct ZipStats
));
799 cpylen
= rb_linebuf_get(&server
->localClient
->buf_recvq
, xbuf
, left
, LINEBUF_PARTIAL
, LINEBUF_RAW
);
801 xbuf
= (void *) (((uintptr_t) xbuf
) + cpylen
);
805 /* Pass the socket to ssld. */
807 if(rb_socketpair(AF_UNIX
, SOCK_STREAM
, 0, &xF1
, &xF2
, "Initial zlib socketpairs") == -1)
809 sendto_realops_snomask(SNO_GENERAL
, L_ALL
, "Error creating zlib socketpair - %s", strerror(errno
));
810 ilog(L_MAIN
, "Error creating zlib socketpairs - %s", strerror(errno
));
811 exit_client(server
, server
, server
, "Error creating zlib socketpair");
817 /* tell ssld the new connid for the ssl part*/
819 uint32_to_buf(&buf2
[1], rb_get_fd(server
->localClient
->F
));
820 uint32_to_buf(&buf2
[5], rb_get_fd(xF2
));
821 ssl_cmd_write_queue(server
->localClient
->ssl_ctl
, NULL
, 0, buf2
, sizeof(buf2
));
825 F
[0] = server
->localClient
->F
;
827 del_from_cli_connid_hash(server
);
828 server
->localClient
->F
= xF2
;
829 /* need to redo as what we did before isn't valid now */
830 uint32_to_buf(&buf
[1], rb_get_fd(server
->localClient
->F
));
831 add_to_cli_connid_hash(server
);
833 server
->localClient
->z_ctl
= which_ssld();
834 server
->localClient
->z_ctl
->cli_count
++;
835 ssl_cmd_write_queue(server
->localClient
->z_ctl
, F
, 2, buf
, len
);
840 collect_zipstats(void *unused
)
843 struct Client
*target_p
;
844 char buf
[sizeof(uint8_t) + sizeof(uint32_t) + HOSTLEN
];
850 odata
= buf
+ sizeof(uint8_t) + sizeof(uint32_t);
852 RB_DLINK_FOREACH(ptr
, serv_list
.head
)
854 target_p
= ptr
->data
;
855 if(IsCapable(target_p
, CAP_ZIP
))
857 len
= sizeof(uint8_t) + sizeof(uint32_t);
859 id
= rb_get_fd(target_p
->localClient
->F
);
860 uint32_to_buf(&buf
[1], id
);
861 rb_strlcpy(odata
, target_p
->name
, (sizeof(buf
) - len
));
862 len
+= strlen(odata
) + 1; /* Get the \0 as well */
863 ssl_cmd_write_queue(target_p
->localClient
->z_ctl
, NULL
, 0, buf
, len
);
869 cleanup_dead_ssl(void *unused
)
871 rb_dlink_node
*ptr
, *next
;
873 RB_DLINK_FOREACH_SAFE(ptr
, next
, ssl_daemons
.head
)
876 if(ctl
->dead
&& !ctl
->cli_count
)
878 free_ssl_daemon(ctl
);
892 rb_event_addish("collect_zipstats", collect_zipstats
, NULL
, ZIPSTATS_TIME
);
893 rb_event_addish("cleanup_dead_ssld", cleanup_dead_ssl
, NULL
, 60);