You are viewing a plain text version of this content. The canonical link for it is here.
Posted to cvs@httpd.apache.org by Dean Gaudet <dg...@hyperreal.com> on 1997/06/22 00:27:13 UTC

cvs commit: apache/src http_config.c http_main.c

dgaudet     97/06/21 15:27:13

  Modified:    src       http_config.c http_main.c
  Log:
  That last fix didn't quite fix the USR1 problem.  This one seems to.
  Eliminate all the "listeners == NULL" code by making sure there's always
  at least one listener, the default one.  This gets rid of some code
  duplication.
  
  Revision  Changes    Path
  1.50      +22 -1     apache/src/http_config.c
  
  Index: http_config.c
  ===================================================================
  RCS file: /export/home/cvs/apache/src/http_config.c,v
  retrieving revision 1.49
  retrieving revision 1.50
  diff -C3 -r1.49 -r1.50
  *** http_config.c	1997/05/15 23:39:20	1.49
  --- http_config.c	1997/06/21 22:27:10	1.50
  ***************
  *** 1074,1079 ****
  --- 1074,1099 ----
        return s;
    }
    
  + 
  + static void default_listeners(pool *p, server_rec *s)
  + {
  +     listen_rec *new;
  + 
  +     if (listeners != NULL) {
  + 	return;
  +     }
  +     /* allocate a default listener */
  +     new = pcalloc(p, sizeof(listen_rec));
  +     new->local_addr.sin_family = AF_INET;
  +     new->local_addr.sin_addr.s_addr = htonl(INADDR_ANY);
  +     new->local_addr.sin_port = htons(s->port);
  +     new->fd = -1;
  +     new->used = 0;
  +     new->next = NULL;
  +     listeners = new;
  + }
  + 
  + 
    server_rec *read_config(pool *p, pool *ptemp, char *confname)
    {
        server_rec *s = init_server_config(p);
  ***************
  *** 1088,1098 ****
        process_resource_config (s, s->access_confname, p, ptemp);
        
        fixup_virtual_hosts (p, s);
        
        for (m = top_module; m; m = m->next)
            if (m->init)
    	    (*m->init) (s, p);
  !     
        return s;
    }
    
  --- 1108,1119 ----
        process_resource_config (s, s->access_confname, p, ptemp);
        
        fixup_virtual_hosts (p, s);
  +     default_listeners (p, s);
        
        for (m = top_module; m; m = m->next)
            if (m->init)
    	    (*m->init) (s, p);
  ! 
        return s;
    }
    
  
  
  
  1.157     +76 -127   apache/src/http_main.c
  
  Index: http_main.c
  ===================================================================
  RCS file: /export/home/cvs/apache/src/http_main.c,v
  retrieving revision 1.156
  retrieving revision 1.157
  diff -C3 -r1.156 -r1.157
  *** http_main.c	1997/06/21 20:48:14	1.156
  --- http_main.c	1997/06/21 22:27:11	1.157
  ***************
  *** 1894,1944 ****
    static listen_rec *old_listeners;
    
    static void copy_listeners(pool *p)
  !     {
        listen_rec *lr;
    
        assert(old_listeners == NULL);
  !     for(lr=listeners ; lr ; lr=lr->next)
  ! 	{
  ! 	listen_rec *nr=malloc(sizeof *nr);
    	if (nr == NULL) {
  ! 	  fprintf (stderr, "Ouch!  malloc failed in copy_listeners()\n");
  ! 	  exit (1);
    	}
  ! 	*nr=*lr;
  ! 	kill_cleanups_for_socket(p,nr->fd);
  ! 	nr->next=old_listeners;
    	assert(!nr->used);
  ! 	old_listeners=nr;
  ! 	}
        }
    
    static int find_listener(listen_rec *lr)
  !     {
        listen_rec *or;
    
  !     for(or=old_listeners ; or ; or=or->next)
  ! 	if(!memcmp(&or->local_addr,&lr->local_addr,sizeof or->local_addr))
  ! 	    {
  ! 	    or->used=1;
    	    return or->fd;
  ! 	    }
  !     return -1;
        }
    
    static void close_unused_listeners()
  !     {
  !     listen_rec *or,*next;
    
  !     for(or=old_listeners ; or ; or=next)
  ! 	{
  ! 	next=or->next;
  ! 	if(!or->used)
    	    closesocket(or->fd);
    	free(or);
  - 	}
  -     old_listeners=NULL;
        }
    
    
    static int s_iInitCount = 0;
  --- 1894,1944 ----
    static listen_rec *old_listeners;
    
    static void copy_listeners(pool *p)
  ! {
        listen_rec *lr;
    
        assert(old_listeners == NULL);
  !     for (lr = listeners; lr; lr = lr->next) {
  ! 	listen_rec *nr = malloc(sizeof *nr);
    	if (nr == NULL) {
  ! 	    fprintf (stderr, "Ouch!  malloc failed in copy_listeners()\n");
  ! 	    exit (1);
    	}
  ! 	*nr = *lr;
  ! 	kill_cleanups_for_socket(p, nr->fd);
  ! 	nr->next = old_listeners;
    	assert(!nr->used);
  ! 	old_listeners = nr;
        }
  + }
  + 
    
    static int find_listener(listen_rec *lr)
  ! {
        listen_rec *or;
    
  !     for (or = old_listeners; or; or = or->next) {
  ! 	if (!memcmp(&or->local_addr, &lr->local_addr, sizeof(or->local_addr))) {
  ! 	    or->used = 1;
    	    return or->fd;
  ! 	}
        }
  +     return -1;
  + }
  + 
    
    static void close_unused_listeners()
  ! {
  !     listen_rec *or, *next;
    
  !     for (or = old_listeners; or; or = next) {
  ! 	next = or->next;
  ! 	if (!or->used)
    	    closesocket(or->fd);
    	free(or);
        }
  +     old_listeners = NULL;
  + }
    
    
    static int s_iInitCount = 0;
  ***************
  *** 2019,2024 ****
  --- 2019,2025 ----
    #endif
        struct sockaddr sa_server;
        struct sockaddr sa_client;
  +     listen_rec *lr;
    
        csd = -1;
        dupped_csd = -1;
  ***************
  *** 2090,2101 ****
    
    	(void)update_child_status(child_num, SERVER_READY, (request_rec*)NULL);
    
  -         if (listeners == NULL) {
  -             FD_ZERO(&listenfds);
  -             FD_SET(sd, &listenfds);
  -             listenmaxfd = sd;
  -         }
  - 
            /*
             * Wait for an acceptable connection to arrive.
             */
  --- 2091,2096 ----
  ***************
  *** 2122,2133 ****
                if (srv <= 0)
                    continue;
    
  !             if (listeners != NULL) {
  !                 for (sd = listenmaxfd; sd >= 0; sd--)
  !                     if (FD_ISSET(sd, &main_fds)) break;
  !                 if (sd < 0)
  !                     continue;
                }
    
    	    /* if we accept() something we don't want to die, so we have to
    	     * defer the exit
  --- 2117,2127 ----
                if (srv <= 0)
                    continue;
    
  ! 	    for (lr = listeners; lr; lr = lr->next) {
  ! 		if (FD_ISSET(lr->fd, &main_fds)) break;
                }
  + 	    if (lr == NULL) continue;
  + 	    sd = lr->fd;
    
    	    /* if we accept() something we don't want to die, so we have to
    	     * defer the exit
  ***************
  *** 2338,2348 ****
    void standalone_main(int argc, char **argv)
    {
        struct sockaddr_in sa_server;
  -     int saved_sd;
        int remaining_children_to_start;
    
        standalone = 1;
  !     sd = listenmaxfd = -1;
    
        is_graceful = 0;
        ++generation;
  --- 2332,2342 ----
    void standalone_main(int argc, char **argv)
    {
        struct sockaddr_in sa_server;
        int remaining_children_to_start;
  +     listen_rec *lr;
    
        standalone = 1;
  !     listenmaxfd = -1;
    
        is_graceful = 0;
        ++generation;
  ***************
  *** 2351,2357 ****
    
        do {
    	copy_listeners(pconf);
  - 	saved_sd = sd;
    	if (!is_graceful) {
    	    restart_time = time(NULL);
    	}
  --- 2345,2350 ----
  ***************
  *** 2379,2416 ****
    
    	default_server_hostnames (server_conf);
    
  ! 	if (listeners == NULL) {
  ! 	    if (!is_graceful) {
  ! 		memset ((char *)&sa_server, 0, sizeof (sa_server));
  ! 		sa_server.sin_family = AF_INET;
  ! 		sa_server.sin_addr = bind_address;
  ! 		sa_server.sin_port = htons (server_conf->port);
  ! 		sd = make_sock (pconf, &sa_server);
  ! 	    }
  ! 	    else {
  ! 		sd = saved_sd;
  ! 		note_cleanups_for_fd(pconf, sd);
  ! 	    }
  ! 	}
  ! 	else {
  ! 	    listen_rec *lr;
    	    int fd;
  ! 
  ! 	    listenmaxfd = -1;
  ! 	    FD_ZERO (&listenfds);
  ! 	    for (lr = listeners; lr != NULL; lr = lr->next)
  ! 	    {
  ! 		fd = find_listener (lr);
  ! 		if (fd < 0) {
  ! 		    fd = make_sock (pconf, &lr->local_addr);
  ! 		}
  ! 		FD_SET (fd, &listenfds);
  ! 		if (fd > listenmaxfd) listenmaxfd = fd;
  ! 		lr->fd = fd;
    	    }
  ! 	    close_unused_listeners ();
  ! 	    sd = -1;
    	}
    
    	set_signals ();
    	log_pid (pconf, pid_fname);
  --- 2372,2391 ----
    
    	default_server_hostnames (server_conf);
    
  ! 	listenmaxfd = -1;
  ! 	FD_ZERO (&listenfds);
  ! 	for (lr = listeners; lr != NULL; lr = lr->next) {
    	    int fd;
  ! 	    
  ! 	    fd = find_listener (lr);
  ! 	    if (fd < 0) {
  ! 		fd = make_sock (pconf, &lr->local_addr);
    	    }
  ! 	    FD_SET (fd, &listenfds);
  ! 	    if (fd > listenmaxfd) listenmaxfd = fd;
  ! 	    lr->fd = fd;
    	}
  + 	close_unused_listeners ();
    
    	set_signals ();
    	log_pid (pconf, pid_fname);
  ***************
  *** 2519,2525 ****
    	    update_scoreboard_global ();
    
    	    log_error ("SIGUSR1 received.  Doing graceful restart",server_conf);
  - 	    kill_cleanups_for_socket (pconf, sd);
    	    /* kill off the idle ones */
    	    if (ap_killpg(pgrp, SIGUSR1) < 0) {
    		log_unixerr ("killpg SIGUSR1", NULL, NULL, server_conf);
  --- 2494,2499 ----
  ***************
  *** 3018,3024 ****
         * useful on Unix (not sure it even makes sense
         * in a multi-threaded env.
         */
  -     int saved_sd;
        int nthreads;
        fd_set main_fds;
        int srv;
  --- 2992,2997 ----
  ***************
  *** 3056,3062 ****
        ++generation;
      
        copy_listeners(pconf);
  -     saved_sd=sd;
        restart_time = time(NULL);
    
        reinit_scoreboard(pconf);
  --- 3029,3034 ----
  ***************
  *** 3064,3101 ****
    
        acquire_mutex(start_mutex);
        {
            listenmaxfd = -1;
    	FD_ZERO(&listenfds);
    
  !         if (listeners == NULL) {
  ! 	    memset((char *) &sa_server, 0, sizeof(sa_server));
  ! 	    sa_server.sin_family=AF_INET;
  ! 	    sa_server.sin_addr=bind_address;
  ! 	    sa_server.sin_port=htons(server_conf->port);
  ! 
  ! 	    sd = make_sock(pconf, &sa_server);
  !             FD_SET(sd, &listenfds);
  !             listenmaxfd = sd;
  !         }
  !         else {
  ! 	    listen_rec *lr;
  ! 	    int fd;
  ! 
  ! 	    
  ! 	    for (lr=listeners; lr != NULL; lr=lr->next)
    	    {
  ! 	        fd=find_listener(lr);
  ! 	        if(fd < 0)
  !                 {
  ! 		    fd = make_sock(pconf, &lr->local_addr);
  !                 }
  ! 	        FD_SET(fd, &listenfds);
  ! 	        if (fd > listenmaxfd) listenmaxfd = fd;
  ! 	        lr->fd=fd;
    	    }
  ! 	    close_unused_listeners();
  ! 	    sd = -1;
  !         }
        }
    
        set_signals();
  --- 3036,3060 ----
    
        acquire_mutex(start_mutex);
        {
  + 	listen_rec *lr;
  + 	int fd;
  + 
            listenmaxfd = -1;
    	FD_ZERO(&listenfds);
    
  ! 	for (lr=listeners; lr != NULL; lr=lr->next)
  ! 	{
  ! 	    fd=find_listener(lr);
  ! 	    if(fd < 0)
    	    {
  ! 		fd = make_sock(pconf, &lr->local_addr);
    	    }
  ! 	    FD_SET(fd, &listenfds);
  ! 	    if (fd > listenmaxfd) listenmaxfd = fd;
  ! 	    lr->fd=fd;
  ! 	}
  ! 	close_unused_listeners();
  ! 	sd = -1;
        }
    
        set_signals();
  ***************
  *** 3140,3159 ****
                start_mutex_released = 1;
                /* set the listen queue to 1 */
                {
  !                 if (listeners == NULL) {
  ! 	            listen(sd, 1);
  !                 }
  !                 else {
  ! 	            listen_rec *lr;
  ! 	            
  ! 	            for (lr=listeners; lr != NULL; lr=lr->next)
  ! 	            {
  ! 	                if(lr->used)
  !                         {
  !                             listen(lr->fd, 1);
  !                         }
  ! 	            }
  !                 }
                }
            }
            if(!start_exit)
  --- 3099,3113 ----
                start_mutex_released = 1;
                /* set the listen queue to 1 */
                {
  ! 		listen_rec *lr;
  ! 		
  ! 		for (lr=listeners; lr != NULL; lr=lr->next)
  ! 		{
  ! 		    if(lr->used)
  ! 		    {
  ! 			listen(lr->fd, 1);
  ! 		    }
  ! 		}
                }
            }
            if(!start_exit)
  ***************
  *** 3200,3206 ****
                    continue;
            }
    
  !         if (listeners != NULL) {
    	    listen_rec *lr;
    	    int fd;
    	    
  --- 3154,3160 ----
                    continue;
            }
    
  !         {
    	    listen_rec *lr;
    	    int fd;
    	    
  ***************
  *** 3254,3274 ****
        }
                
        {
  !         if (listeners == NULL) {
  ! 	    closesocket(sd);
  !         }
  !         else {
  ! 	    listen_rec *lr;
  ! 	    
  ! 	    for (lr=listeners; lr != NULL; lr=lr->next)
    	    {
  ! 	        if(lr->used)
  !                 {
  !                     closesocket(lr->fd);
  !                     lr->fd = -1;
  !                 }
    	    }
  !         }
        }
    
        for(i=0; i<nthreads; i++)
  --- 3208,3223 ----
        }
                
        {
  ! 	listen_rec *lr;
  ! 	
  ! 	for (lr=listeners; lr != NULL; lr=lr->next)
  ! 	{
  ! 	    if(lr->used)
    	    {
  ! 		closesocket(lr->fd);
  ! 		lr->fd = -1;
    	    }
  ! 	}
        }
    
        for(i=0; i<nthreads; i++)