kadm_conn.c
1 /* 2 * Copyright (c) 2000 - 2004 Kungliga Tekniska Högskolan 3 * (Royal Institute of Technology, Stockholm, Sweden). 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * 3. Neither the name of the Institute nor the names of its contributors 18 * may be used to endorse or promote products derived from this software 19 * without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 */ 33 34 #include "kadmin_locl.h" 35 #ifdef HAVE_SYS_WAIT_H 36 #include <sys/wait.h> 37 #endif 38 39 struct kadm_port { 40 char *port; 41 unsigned short def_port; 42 struct kadm_port *next; 43 } *kadm_ports; 44 45 static void 46 add_kadm_port(krb5_context contextp, const char *service, unsigned int port) 47 { 48 struct kadm_port *p; 49 p = malloc(sizeof(*p)); 50 if(p == NULL) { 51 krb5_warnx(contextp, "failed to allocate %lu bytes\n", 52 (unsigned long)sizeof(*p)); 53 return; 54 } 55 56 p->port = strdup(service); 57 p->def_port = port; 58 59 p->next = kadm_ports; 60 kadm_ports = p; 61 } 62 63 static void 64 add_standard_ports (krb5_context contextp) 65 { 66 add_kadm_port(contextp, "kerberos-adm", 749); 67 } 68 69 /* 70 * parse the set of space-delimited ports in `str' and add them. 71 * "+" => all the standard ones 72 * otherwise it's port|service[/protocol] 73 */ 74 75 void 76 parse_ports(krb5_context contextp, const char *str) 77 { 78 char p[128]; 79 80 while(strsep_copy(&str, " \t", p, sizeof(p)) != -1) { 81 if(strcmp(p, "+") == 0) 82 add_standard_ports(contextp); 83 else 84 add_kadm_port(contextp, p, 0); 85 } 86 } 87 88 static pid_t pgrp; 89 sig_atomic_t term_flag, doing_useful_work; 90 91 static RETSIGTYPE 92 sigchld(int sig) 93 { 94 int status; 95 /* 96 * waitpid() is async safe. will return -1 or 0 on no more zombie 97 * children 98 */ 99 while ((waitpid(-1, &status, WNOHANG)) > 0) 100 ; 101 SIGRETURN(0); 102 } 103 104 static RETSIGTYPE 105 terminate(int sig) 106 { 107 if(getpid() == pgrp) { 108 /* parent */ 109 term_flag = 1; 110 signal(sig, SIG_IGN); 111 killpg(pgrp, sig); 112 } else { 113 /* child */ 114 if(doing_useful_work) 115 term_flag = 1; 116 else 117 exit(0); 118 } 119 SIGRETURN(0); 120 } 121 122 static int 123 spawn_child(krb5_context contextp, int *socks, 124 unsigned int num_socks, int this_sock) 125 { 126 int e; 127 size_t i; 128 struct sockaddr_storage __ss; 129 struct sockaddr *sa = (struct sockaddr *)&__ss; 130 socklen_t sa_size = sizeof(__ss); 131 krb5_socket_t s; 132 pid_t pid; 133 krb5_address addr; 134 char buf[128]; 135 size_t buf_len; 136 137 s = accept(socks[this_sock], sa, &sa_size); 138 if(rk_IS_BAD_SOCKET(s)) { 139 krb5_warn(contextp, rk_SOCK_ERRNO, "accept"); 140 return 1; 141 } 142 e = krb5_sockaddr2address(contextp, sa, &addr); 143 if(e) 144 krb5_warn(contextp, e, "krb5_sockaddr2address"); 145 else { 146 e = krb5_print_address (&addr, buf, sizeof(buf), 147 &buf_len); 148 if(e) 149 krb5_warn(contextp, e, "krb5_print_address"); 150 else 151 krb5_warnx(contextp, "connection from %s", buf); 152 krb5_free_address(contextp, &addr); 153 } 154 155 pid = fork(); 156 if(pid == 0) { 157 for(i = 0; i < num_socks; i++) 158 rk_closesocket(socks[i]); 159 dup2(s, STDIN_FILENO); 160 dup2(s, STDOUT_FILENO); 161 if(s != STDIN_FILENO && s != STDOUT_FILENO) 162 rk_closesocket(s); 163 return 0; 164 } else { 165 rk_closesocket(s); 166 } 167 return 1; 168 } 169 170 static void 171 wait_for_connection(krb5_context contextp, 172 krb5_socket_t *socks, unsigned int num_socks) 173 { 174 unsigned int i; 175 int e; 176 fd_set orig_read_set, read_set; 177 int status, max_fd = -1; 178 179 FD_ZERO(&orig_read_set); 180 181 for(i = 0; i < num_socks; i++) { 182 #ifdef FD_SETSIZE 183 if (socks[i] >= FD_SETSIZE) 184 errx (1, "fd too large"); 185 #endif 186 FD_SET(socks[i], &orig_read_set); 187 max_fd = max(max_fd, socks[i]); 188 } 189 190 #if 0 /* launchd takes care of our children */ 191 pgrp = getpid(); 192 193 if(setpgid(0, pgrp) < 0) 194 err(1, "setpgid"); 195 #endif 196 197 signal(SIGTERM, terminate); 198 signal(SIGINT, terminate); 199 signal(SIGCHLD, sigchld); 200 201 while (term_flag == 0) { 202 read_set = orig_read_set; 203 e = select(max_fd + 1, &read_set, NULL, NULL, NULL); 204 if(rk_IS_SOCKET_ERROR(e)) { 205 if(rk_SOCK_ERRNO != EINTR) 206 krb5_warn(contextp, rk_SOCK_ERRNO, "select"); 207 } else if(e == 0) 208 krb5_warnx(contextp, "select returned 0"); 209 else { 210 for(i = 0; i < num_socks; i++) { 211 if(FD_ISSET(socks[i], &read_set)) 212 if(spawn_child(contextp, socks, num_socks, i) == 0) 213 return; 214 } 215 } 216 } 217 signal(SIGCHLD, SIG_IGN); 218 219 while ((waitpid(-1, &status, WNOHANG)) > 0) 220 ; 221 222 exit(0); 223 } 224 225 226 void 227 start_server(krb5_context contextp, const char *port_str) 228 { 229 int e; 230 struct kadm_port *p; 231 232 krb5_socket_t *socks = NULL, *tmp; 233 unsigned int num_socks = 0; 234 int i; 235 236 if (port_str == NULL) 237 port_str = "+"; 238 239 parse_ports(contextp, port_str); 240 241 for(p = kadm_ports; p; p = p->next) { 242 struct addrinfo hints, *ai, *ap; 243 char portstr[32]; 244 memset (&hints, 0, sizeof(hints)); 245 hints.ai_flags = AI_PASSIVE; 246 hints.ai_socktype = SOCK_STREAM; 247 248 e = getaddrinfo(NULL, p->port, &hints, &ai); 249 if(e) { 250 snprintf(portstr, sizeof(portstr), "%u", p->def_port); 251 e = getaddrinfo(NULL, portstr, &hints, &ai); 252 } 253 254 if(e) { 255 krb5_warn(contextp, krb5_eai_to_heim_errno(e, errno), 256 "%s", portstr); 257 continue; 258 } 259 i = 0; 260 for(ap = ai; ap; ap = ap->ai_next) 261 i++; 262 tmp = realloc(socks, (num_socks + i) * sizeof(*socks)); 263 if(tmp == NULL) { 264 krb5_warnx(contextp, "failed to reallocate %lu bytes", 265 (unsigned long)(num_socks + i) * sizeof(*socks)); 266 continue; 267 } 268 socks = tmp; 269 for(ap = ai; ap; ap = ap->ai_next) { 270 krb5_socket_t s = socket(ap->ai_family, ap->ai_socktype, ap->ai_protocol); 271 if(rk_IS_BAD_SOCKET(s)) { 272 krb5_warn(contextp, rk_SOCK_ERRNO, "socket"); 273 continue; 274 } 275 276 socket_set_reuseaddr(s, 1); 277 socket_set_ipv6only(s, 1); 278 279 if (rk_IS_SOCKET_ERROR(bind (s, ap->ai_addr, ap->ai_addrlen))) { 280 krb5_warn(contextp, rk_SOCK_ERRNO, "bind"); 281 rk_closesocket(s); 282 continue; 283 } 284 if (rk_IS_SOCKET_ERROR(listen (s, SOMAXCONN))) { 285 krb5_warn(contextp, rk_SOCK_ERRNO, "listen"); 286 rk_closesocket(s); 287 continue; 288 } 289 socks[num_socks++] = s; 290 } 291 freeaddrinfo (ai); 292 } 293 if(num_socks == 0) 294 krb5_errx(contextp, 1, "no sockets to listen to - exiting"); 295 296 wait_for_connection(contextp, socks, num_socks); 297 }