static foreign_t pl_win_open_console(term_t title, term_t input, term_t output, term_t error, term_t options) { rlc_console_attr attr; rlc_console c; IOSTREAM *in, *out, *err; TCHAR *s; size_t len; memset(&attr, 0, sizeof(attr)); if ( !PL_get_wchars(title, &len, &s, CVT_ALL|BUF_RING) ) return type_error(title, "text"); attr.title = (const TCHAR*) s; if ( !process_console_options(&attr, options) ) return FALSE; c = rlc_create_console(&attr); create_prolog_hidden_window(c); /* for sending messages */ registerConsole(c); #define STREAM_COMMON (SIO_TEXT| /* text-stream */ \ SIO_NOCLOSE| /* do no close on abort */ \ SIO_ISATTY| /* terminal */ \ SIO_NOFEOF) /* reset on end-of-file */ in = Snew(c, SIO_INPUT|SIO_LBUF|STREAM_COMMON, &rlc_functions); out = Snew(c, SIO_OUTPUT|SIO_LBUF|STREAM_COMMON, &rlc_functions); err = Snew(c, SIO_OUTPUT|SIO_NBUF|STREAM_COMMON, &rlc_functions); in->position = &in->posbuf; /* record position on same stream */ out->position = &in->posbuf; err->position = &in->posbuf; in->encoding = ENC_WCHAR; out->encoding = ENC_WCHAR; err->encoding = ENC_WCHAR; if ( !PL_unify_stream(input, in) || !PL_unify_stream(output, out) || !PL_unify_stream(error, err) ) { Sclose(in); Sclose(out); Sclose(err); rlc_close(c); return FALSE; } rlc_set(c, RLC_PROLOG_INPUT, (uintptr_t)in, NULL); rlc_set(c, RLC_PROLOG_OUTPUT, (uintptr_t)out, NULL); rlc_set(c, RLC_PROLOG_ERROR, (uintptr_t)err, free_stream); return TRUE; }
static void stream_discard( const struct server *serp ) { char buf[ BUFFER_SIZE ] ; int cc ; int descriptor = SERVER_FD( serp ) ; struct service *svc = SERVER_SERVICE( serp ) ;; if( SVC_WAITS( svc ) ) { descriptor = accept(descriptor, NULL, NULL); if ( descriptor == -1 ) { if ((errno == EMFILE) || (errno == ENFILE)) cps_service_stop(svc, "no available descriptors"); return; } } close_all_svc_descriptors(); for ( ;; ) { cc = read( descriptor, buf, sizeof( buf ) ) ; if ( (cc == 0) || ((cc == -1) && (errno != EINTR)) ) break ; } if( SVC_WAITS( svc ) ) /* Service forks, so close it */ Sclose(descriptor); }
static int chunked_close(void *handle) { chunked_context *ctx = handle; int rc = 0; DEBUG(1, Sdprintf("chunked_close() ...\n")); if ( (ctx->chunked_stream->flags & SIO_OUTPUT) ) { if ( Sfprintf(ctx->stream, "0\r\n\r\n") < 0 ) rc = -1; } ctx->stream->encoding = ctx->parent_encoding; if ( ctx->close_parent ) { IOSTREAM *parent = ctx->stream; int rc2; free_chunked_context(ctx); rc2 = Sclose(parent); if ( rc == 0 ) rc = rc2; } else { free_chunked_context(ctx); } return rc; }
static void stream_chargen( const struct server *serp ) { char line_buf[ LINE_LENGTH+2 ] ; int descriptor = SERVER_FD( serp ) ; struct service *svc = SERVER_SERVICE( serp ); if( SVC_WAITS( svc ) ) { descriptor = accept(descriptor, NULL, NULL); if ( descriptor == -1 ) { if ((errno == EMFILE) || (errno == ENFILE)) cps_service_stop(svc, "no available descriptors"); return; } } (void) shutdown( descriptor, 0 ) ; close_all_svc_descriptors(); for ( ;; ) { if ( generate_line( line_buf, sizeof( line_buf ) ) == NULL ) break ; if ( write_buf( descriptor, line_buf, sizeof( line_buf ) ) == FAILED ) break ; } if( SVC_WAITS( svc ) ) /* Service forks, so close it */ Sclose(descriptor); }
static void initDefaultOptions() { GD->options.compileOut = store_string("a.out"); GD->options.localSize = systemDefaults.local K; GD->options.globalSize = systemDefaults.global K; GD->options.trailSize = systemDefaults.trail K; GD->options.goal = store_string(systemDefaults.goal); GD->options.topLevel = store_string(systemDefaults.toplevel); GD->options.initFile = store_string(systemDefaults.startup); GD->options.scriptFiles = NULL; GD->options.saveclass = store_string("none"); if ( !GD->bootsession && GD->resourceDB ) { IOSTREAM *op = SopenRC(GD->resourceDB, "$options", "$prolog", RC_RDONLY); if ( op ) { char name[MAXVARNAME]; char val[MAXVARVAL]; while( getVarFromStream(op, name, val) ) set_pl_option(name, val); Sclose(op); } } }
static void initDefaultOptions(void) { GD->options.compileOut = store_string("a.out"); GD->options.stackLimit = systemDefaults.stack_limit; GD->options.tableSpace = systemDefaults.table_space; GD->options.topLevel = store_string(systemDefaults.toplevel); GD->options.initFile = store_string(systemDefaults.startup); GD->options.scriptFiles = NULL; GD->options.saveclass = store_string("none"); if ( systemDefaults.goal ) opt_append(&GD->options.goals, systemDefaults.goal); if ( !GD->bootsession && GD->resources.DB ) { IOSTREAM *op = SopenZIP(GD->resources.DB, "$prolog/options.txt", RC_RDONLY); if ( op ) { tmp_buffer name; tmp_buffer val; while( getVarFromStream(op, &name, &val) ) { set_pl_option(baseBuffer(&name, char), baseBuffer(&val, char)); discardBuffer(&name); discardBuffer(&val); } Sclose(op); } }
/* * Read the entry line-by-line and add the information in scp * Use defaults to initialize modifiable entry fields. */ static status_e parse_entry( entry_e entry_type, int fd, struct service_config *scp ) { static pset_h attr_values = NULL; char *line ; char *attr_name ; enum assign_op op ; const char *func = "parse_entry" ; if ( ! attr_values && ( attr_values = pset_create( 10, 10 ) ) == NULL ) { out_of_memory( func ) ; return( FAILED ) ; } for ( ;; ) { line = next_line( fd ) ; if ( line == CHAR_NULL ) { parsemsg( LOG_ERR, func, "incomplete entry" ) ; return( FAILED ) ; } if ( line_has_only_1_char( line, ENTRY_END ) ) return( OK ) ; if ( parse_line( line, &attr_name, &op, attr_values ) == FAILED ) { pset_clear( attr_values ) ; return( FAILED ) ; } if (identify_attribute( entry_type, scp, attr_name, op, attr_values ) == FAILED ) { /* * An error was detected in the default section. We will terminate * since whatever attribute being specified cannot be propagated. */ msg(LOG_ERR, func, "A fatal error was encountered while parsing the default section." " xinetd will exit."); Sclose( fd ); terminate_program(); } pset_clear( attr_values ) ; } }
static int ar_close(struct archive *a, void *cdata) { archive_wrapper *ar = cdata; PL_release_stream(ar->data); if ( ar->close_parent ) { if ( Sclose(ar->data) != 0 ) { archive_set_error(ar->archive, errno, "Close failed"); ar->data = NULL; return ARCHIVE_FATAL; } ar->data = NULL; } return ARCHIVE_OK; /* TBD: close_parent */ }
/* * This function closes all service descriptors. This should be called * for all child processes that fork, but do not exec. This includes * redirect, builtins, and tcpmux. The close on exec flag takes care of * child processes that call exec. Without calling this, the listening * fd's are not closed and reconfig will fail. */ void close_all_svc_descriptors(void) { psi_h iter ; struct service *osp ; /* Have to close all other descriptors here */ iter = psi_create( SERVICES( ps ) ) ; if ( iter == NULL ) { out_of_memory( "close_all_svc_descriptors" ) ; exit( 1 ); } for ( osp = SP( psi_start( iter ) ) ; osp ; osp = SP( psi_next( iter ) ) ) (void) Sclose( SVC_FD( osp ) ) ; psi_destroy( iter ) ; }
static void stream_daytime( const struct server *serp ) { char time_buf[ BUFFER_SIZE ] ; unsigned int buflen = sizeof( time_buf ) ; int descriptor = SERVER_FD( serp ) ; struct service *svc = SERVER_SERVICE( serp ) ;; if( SVC_WAITS( svc ) ) { descriptor = accept(descriptor, NULL, NULL); if ( descriptor == -1 ) { if ((errno == EMFILE) || (errno == ENFILE)) cps_service_stop(svc, "no available descriptors"); return; } } daytime_protocol( time_buf, &buflen ) ; (void) write_buf( descriptor, time_buf, buflen ) ; Sclose(descriptor); }
static void stream_time( const struct server *serp ) { unsigned char time_buf[4]; int descriptor = SERVER_FD( serp ); struct service *svc = SERVER_SERVICE( serp ); if( SVC_WAITS( svc ) ) { descriptor = accept(descriptor, NULL, NULL); if ( descriptor == -1 ) { if ((errno == EMFILE) || (errno == ENFILE)) cps_service_stop(svc, "no available descriptors"); return; } } time_protocol( time_buf ) ; (void) write_buf( descriptor, (char *) time_buf, 4 ) ; Sclose(descriptor); }
static foreign_t archive_open_entry(term_t archive, term_t stream) { archive_wrapper *ar; IOSTREAM *s; if ( !get_archive(archive, &ar) ) return FALSE; if ( (s=Snew(ar, SIO_INPUT|SIO_RECORDPOS, &ar_entry_functions)) ) { ar->status = AR_OPENED_ENTRY; if ( PL_unify_stream(stream, s) ) { PL_register_atom(ar->symbol); /* We may no longer reference the */ return TRUE; /* archive itself */ } Sclose(s); return FALSE; } return PL_resource_error("memory"); }
static int banner_fail( const struct service *sp, const connection_s *cp ) { const char *func = "banner_fail"; const struct service_config *scp = SVC_CONF( sp ) ; if ( SC_BANNER_FAIL(scp) != NULL ) { char tmpbuf[TMPSIZE]; int retval; int bannerfd = open(SC_BANNER_FAIL(scp), O_RDONLY); if( bannerfd < 0 ) { msg( LOG_ERR, func, "service = %s, open of banner %s failed", SVC_ID( sp ), SC_BANNER_FAIL(scp)); return(-1); } while( (retval = read(bannerfd, tmpbuf, sizeof(tmpbuf))) ) { if (retval == -1) { if (errno == EINTR) continue; else { msg(LOG_ERR, func, "service %s, Error %m reading banner %s", SVC_ID( sp ), SC_BANNER(scp)); break; } } Swrite(cp->co_descriptor, tmpbuf, retval); } Sclose(bannerfd); Sflush ( cp->co_descriptor ); } return(0); }
static void deactivate( const struct service *sp ) { (void) Sclose( SVC_FD( sp ) ) ; #ifdef HAVE_MDNS xinetd_mdns_deregister(SVC_CONF(sp)); #endif if (debug.on) msg(LOG_DEBUG, "deactivate", "%d Service %s deactivated", getpid(), SC_NAME( SVC_CONF(sp) ) ); #ifndef NO_RPC if ( SC_IS_RPC( SVC_CONF( sp ) ) ) { unsigned long vers ; const struct rpc_data *rdp = SC_RPCDATA( SVC_CONF( sp ) ) ; for ( vers = RD_MINVERS( rdp ) ; vers <= RD_MAXVERS( rdp ) ; vers++ ) { (void) pmap_unset( RD_PROGNUM( rdp ), vers ) ; } } #endif /* ! NO_RPC */ }
static void stream_echo( const struct server *serp ) { char buf[ BUFFER_SIZE ] ; ssize_t cc ; int descriptor = SERVER_FD( serp ) ; struct service *svc = SERVER_SERVICE( serp ) ;; if( SVC_WAITS( svc ) ) { descriptor = accept(descriptor, NULL, NULL); if ( descriptor == -1 ) { if ((errno == EMFILE) || (errno == ENFILE)) cps_service_stop(svc, "no available descriptors"); return; } } close_all_svc_descriptors(); for ( ;; ) { cc = read( descriptor, buf, sizeof( buf ) ) ; if ( cc == 0 ) break ; if ( cc == (ssize_t)-1 ) { if ( errno == EINTR ) continue ; else break ; } if ( write_buf( descriptor, buf, cc ) == FAILED ) break ; } if( SVC_WAITS( svc ) ) /* Service forks, so close it */ Sclose(descriptor); }
void dump_internal_state(void) { int dump_fd ; const char *dump_file = DUMP_FILE ; time_t current_time ; int fd ; unsigned u ; const char *func = "dump_internal_state" ; if ( debug.on ) msg( LOG_DEBUG, func, "Dumping State" ) ; dump_fd = open( dump_file, O_WRONLY | O_CREAT | O_APPEND, DUMP_FILE_MODE); if ( dump_fd == -1 ) { msg( LOG_ERR, func, "failed to open %s: %m", dump_file ) ; return ; } if (Sbuftype( dump_fd, SIO_LINEBUF ) == SIO_ERR ) { /* * If the above function failed, Sprint will most likely * fail, too. Output a message for troubleshooting and quit. */ msg( LOG_ERR, func, "failed setting up sio buffering: %m" ) ; return; } /* * Print the program name, version, and timestamp. * Note that the program_version variable contains the program name. */ (void) time( ¤t_time ) ; Sprint( dump_fd, "INTERNAL STATE DUMP: %s\n", program_version ) ; Sprint( dump_fd, "Current time: %s\n", ctime( ¤t_time ) ) ; dump_services( dump_fd ) ; /* * Dump the server table */ Sprint( dump_fd, "Server table dump:\n" ) ; for ( u = 0 ; u < pset_count( SERVERS( ps ) ) ; u++ ) server_dump( SERP( pset_pointer( SERVERS( ps ), u ) ), dump_fd ) ; Sputchar( dump_fd, '\n' ) ; /* * Dump the retry_table */ Sprint( dump_fd, "Retry table dump:\n" ) ; for ( u = 0 ; u < pset_count( RETRIES( ps ) ) ; u++ ) server_dump( SERP( pset_pointer( RETRIES( ps ), u ) ), dump_fd ) ; Sputchar( dump_fd, '\n' ) ; /* * Dump the socket mask */ Sprint( dump_fd, "Socket mask:" ) ; for ( fd = 0 ; fd < ps.ros.max_descriptors ; fd++ ) if ( FD_ISSET( fd, &ps.rws.socket_mask ) ) Sprint( dump_fd, " %d", fd ) ; Sputchar( dump_fd, '\n' ) ; Sprint( dump_fd, "mask_max = %d\n", ps.rws.mask_max ) ; /* * Dump the descriptors that are open and are *not* in the socket mask */ Sprint( dump_fd, "Open descriptors (not in socket mask):" ) ; for ( fd = 0 ; fd < ps.ros.max_descriptors ; fd++ ) { struct stat st ; if ( FD_ISSET( fd, &ps.rws.socket_mask ) ) continue ; if ( fstat( fd, &st ) == -1 ) continue ; Sprint( dump_fd, " %d", fd ) ; } Sputchar( dump_fd, '\n' ) ; Sputchar( dump_fd, '\n' ) ; Sprint( dump_fd, "active_services = %d\n", ps.rws.active_services ) ; Sprint( dump_fd, "available_services = %d\n", ps.rws.available_services ) ; Sprint( dump_fd, "descriptors_free = %d\n", ps.rws.descriptors_free ) ; Sprint( dump_fd, "running_servers = %d\n", pset_count( SERVERS( ps ) ) ) ; Sprint( dump_fd, "Logging service = %s\n", LOG_SERVICE( ps ) != NULL ? "enabled" : "not enabled" ) ; Sputchar( dump_fd, '\n' ) ; Sprint( dump_fd, "max_descriptors = %d\n", (int)ps.ros.max_descriptors ) ; Sprint( dump_fd, "process_limit = %d\n", (int)ps.ros.process_limit ) ; Sprint( dump_fd, "config_file = %s\n", ps.ros.config_file ) ; if ( debug.on ) Sprint( dump_fd, "debug_fd = %d\n", debug.fd ) ; Sputchar( dump_fd, '\n' ) ; Sprint( dump_fd, "END OF DUMP\n\n" ) ; Sclose( dump_fd ); msg( LOG_INFO, func, "generated state dump in file %s", dump_file ) ; }
static char * findHome(const char *symbols, int argc, const char **argv) { const char *home = NULL; char envbuf[MAXPATHLEN]; char plp[MAXPATHLEN]; const char *val; if ( (val=longopt("home", argc, argv)) ) { if ( (home=PrologPath(val, plp, sizeof(plp))) ) return store_string(home); return NULL; } if ( (val = exec_var("homevar")) && (home = Getenv(val, envbuf, sizeof(envbuf))) && (home = PrologPath(home, plp, sizeof(plp))) ) return store_string(home); if ( (val = exec_var("home")) && (home = PrologPath(val, plp, sizeof(plp))) ) return store_string(home); #ifdef PLHOMEVAR_1 if ( !(home = Getenv(PLHOMEVAR_1, envbuf, sizeof(envbuf))) ) { #ifdef PLHOMEVAR_2 home = Getenv(PLHOMEVAR_2, envbuf, sizeof(envbuf)); #endif } if ( home && (home = PrologPath(home, plp, sizeof(plp))) && ExistsDirectory(home) ) return store_string(home); #endif #ifdef PLHOMEFILE if ( (home = symbols) ) { char buf[MAXPATHLEN]; char parent[MAXPATHLEN]; IOSTREAM *fd; strcpy(parent, DirName(DirName(AbsoluteFile(home, buf), buf), buf)); Ssprintf(buf, "%s/" PLHOMEFILE, parent); if ( (fd = Sopen_file(buf, "r")) ) { if ( Sfgets(buf, sizeof(buf), fd) ) { size_t l = strlen(buf); while(l > 0 && buf[l-1] <= ' ') l--; buf[l] = EOS; #if O_XOS { char buf2[MAXPATHLEN]; _xos_canonical_filename(buf, buf2, MAXPATHLEN, 0); strcpy(buf, buf2); } #endif if ( !IsAbsolutePath(buf) ) { char buf2[MAXPATHLEN]; Ssprintf(buf2, "%s/%s", parent, buf); home = AbsoluteFile(buf2, plp); } else home = AbsoluteFile(buf, plp); if ( ExistsDirectory(home) ) { Sclose(fd); return store_string(home); } } Sclose(fd); } } #endif /*PLHOMEFILE*/ if ( (home = PrologPath(PLHOME, plp, sizeof(plp))) && ExistsDirectory(home) ) return store_string(home); return NULL; }
/* main: */ int main( int argc, char **argv) { int sktcnt = 0; int istat; int ret; Socket *srvr = NULL; Socket *nskt = NULL; if(argc <= 1) { fprintf(stderr,"***usage*** sktfork srvrname\n"); exit(1); } srvr= Sopen(argv[1],"s"); if(!srvr) { fprintf(stderr,"***error*** unable to open <%s> server\n",argv[1]); exit(1); } /* install a SIGCHLD handler */ sigset(SIGCHLD,sigchld_handler); while(1) { printf("Wait for new socket to be accepted\n"); nskt= Saccept(srvr); if(!nskt) { /* presumably I just got a SIGCHLD */ printf("WEXITSTATUS(childstat=%d)=%d\n",childstat,WEXITSTATUS(childstat)); if(WEXITSTATUS(childstat) == 1) break; continue; } else { ++sktcnt; printf("normal new skt: sktcnt=%d\n",sktcnt); } ret= fork(); if(ret == 0) { /* child process */ char buf[BUFSIZE]; Socket *skt; printf("child() skt<%s>",Sprtskt(nskt)); skt = nskt; nskt= NULL; if(!Sgets(buf,BUFSIZE,skt)) { fprintf(stderr,"***error*** unable to Sgets\n"); _exit(0); } Sputs("goodbye!",skt); printf("got <%s>, goodbye!\n",buf); Sclose(skt); skt= NULL; if(!strcmp(buf,"Q")) { printf("return: child 1"); _exit(1); } printf("return: child 0"); _exit(0); } else if(ret == -1) { fprintf(stderr,"***error*** unable to fork\n"); if(nskt) Sclose(nskt); if(srvr) Sclose(srvr); srvr= nskt= NULL; break; } } printf("closing down server: sktcnt=%d\n",sktcnt); if(srvr) Sclose(srvr); srvr= NULL; return 0; }
static char * findHome(char *symbols) { char *home = NULL; char envbuf[MAXPATHLEN]; char plp[MAXPATHLEN]; const char *val; if ( (val = exec_var("homevar")) && (home = getenv3(val, envbuf, sizeof(envbuf))) && (home = PrologPath(home, plp)) ) return store_string(home); if ( (val = exec_var("home")) && (home = PrologPath(home, plp)) ) return store_string(home); if ( !(home = getenv3("SWI_HOME_DIR", envbuf, sizeof(envbuf))) ) home = getenv3("SWIPL", envbuf, sizeof(envbuf)); if ( home && (home = PrologPath(home, plp)) && ExistsDirectory(home) ) return store_string(home); if ( (home = symbols) ) { char buf[MAXPATHLEN]; char parent[MAXPATHLEN]; IOSTREAM *fd; strcpy(parent, DirName(DirName(AbsoluteFile(home, buf), buf), buf)); Ssprintf(buf, "%s/swipl", parent); if ( (fd = Sopen_file(buf, "r")) ) { if ( Sfgets(buf, sizeof(buf), fd) ) { int l = strlen(buf); while(l > 0 && buf[l-1] <= ' ') l--; buf[l] = EOS; #if O_XOS { char buf2[MAXPATHLEN]; _xos_canonical_filename(buf, buf2); strcpy(buf, buf2); } #endif if ( !IsAbsolutePath(buf) ) { char buf2[MAXPATHLEN]; Ssprintf(buf2, "%s/%s", parent, buf); home = AbsoluteFile(buf2, plp); } else home = AbsoluteFile(buf, plp); if ( ExistsDirectory(home) ) { Sclose(fd); return store_string(home); } } Sclose(fd); } } if ( (home = PrologPath(PLHOME, plp)) && ExistsDirectory(home) ) return store_string(home); return NULL; }
/* * Read the configuration file (descriptor fd) and place all * services found there in the configuration. */ void parse_conf_file( int fd, struct configuration *confp, const char *filename) { pset_h sconfs = CNF_SERVICE_CONFS( confp ) ; struct service_config *default_config = CNF_DEFAULTS( confp ) ; boolean_e found_defaults = NO ; struct service_config default_default_config ; const char *func = "parse_conf_file" ; int incfd; line_count = 0 ; current_file = filename; CLEAR( default_default_config ) ; for ( ;; ) { entry_e entry_type ; char *service_name = NULL; /* * if find_next_entry is successful, service_name * will point to malloc'ed memory */ entry_type = find_next_entry( fd, &service_name ) ; switch ( entry_type ) { case INCLUDE_ENTRY: { int saved_line_count = line_count; incfd = open(service_name, O_RDONLY); if( incfd < 0 ) { parsemsg( LOG_ERR, func, "Unable to open included configuration file: %s", service_name); break; } parsemsg( LOG_DEBUG,func, "Reading included configuration file: %s",service_name); parse_conf_file(incfd, confp, service_name); /* * parse_conf_file eventually calls Srdline, try Sclosing it * to unmmap memory. */ Sclose(incfd); /* Restore since we've returned from included file */ current_file = filename; line_count = saved_line_count; } break; case INCLUDEDIR_ENTRY: { int saved_line_count = line_count; handle_includedir(service_name, confp); current_file = filename; line_count = saved_line_count; } break; case SERVICE_ENTRY: get_service_entry( fd, sconfs, service_name, default_config ) ; break ; case DEFAULTS_ENTRY: if ( found_defaults == YES ) { parsemsg( LOG_ERR, func, "only 1 defaults entry is allowed. This entry will be ignored" ) ; skip_entry( fd ) ; } else if ( parse_entry( DEFAULTS_ENTRY, fd, default_config ) == OK ) { found_defaults = YES ; /* * We must check bind_address to see if it was deferred. */ if (SC_SPECIFIED( default_config, A_BIND) && SC_BIND_ADDR(default_config) == NULL) M_CLEAR( default_config->sc_specified_attributes, A_BIND ) ; } break ; case BAD_ENTRY: skip_entry( fd ) ; break ; case NO_ENTRY: return ; } if (service_name) free(service_name); } }
static void redir_sigpipe( int signum ) { Sclose(RedirServerFd); _exit(0); }
static void tcpmux_handler( const struct server *serp ) { char svc_name[ BUFFER_SIZE ] ; int cc ; int descriptor = SERVER_FD( serp ) ; const struct service *svc = SERVER_SERVICE( serp ) ; unsigned u; struct service *sp = NULL; struct server server, *nserp; struct service_config *scp = NULL; close_all_svc_descriptors(); /* Read in the name of the service in the format "svc_name\r\n". * * XXX: should loop on partial reads (could probably use Sread() if * it wasn't thrown out of xinetd source code a few revisions back). */ do { cc = read( descriptor, svc_name, sizeof( svc_name ) ) ; } while (cc == -1 && errno == EINTR); if ( cc <= 0 ) { msg(LOG_ERR, "tcpmux_handler", "read failed"); exit(0); } if ( ( cc <= 2 ) || ( ( svc_name[cc - 1] != '\n' ) || ( svc_name[cc - 2] != '\r' ) ) ) { if ( debug.on ) msg(LOG_DEBUG, "tcpmux_handler", "Invalid service name format."); exit(0); } svc_name[cc - 2] = '\0'; /* Remove \r\n for compare */ if ( debug.on ) { msg(LOG_DEBUG, "tcpmux_handler", "Input (%d bytes) %s as service name.", cc, svc_name); } /* Search the services for the a match on name. */ for ( u = 0 ; u < pset_count( SERVICES( ps ) ) ; u++ ) { sp = SP( pset_pointer( SERVICES( ps ), u ) ) ; if ( strcasecmp( svc_name, SC_NAME( SVC_CONF( sp ) ) ) == 0 ) { /* Found the pointer. Validate its type. */ scp = SVC_CONF( sp ); /* if ( ! SVC_IS_MUXCLIENT( sp ) ) { if ( debug.on ) { msg(LOG_DEBUG, "tcpmux_handler", "Non-tcpmux service name: %s.", svc_name); } exit(0); } */ /* Send the accept string if we're a PLUS (+) client. */ if ( SVC_IS_MUXPLUSCLIENT( sp ) ) { if ( Swrite( descriptor, TCPMUX_ACK, sizeof( TCPMUX_ACK ) ) != sizeof( TCPMUX_ACK ) ) { msg(LOG_ERR, "tcpmux_handler", "Ack write failed for %s.", svc_name); exit(0); } } break; /* Time to get on with the service */ } continue; /* Keep looking */ } if ( u >= pset_count( SERVICES( ps ) ) ) { if ( debug.on ) { msg(LOG_DEBUG, "tcpmux_handler", "Service name %s not found.", svc_name); } exit(0); } if( SVC_WAITS( svc ) ) /* Service forks, so close it */ Sclose(descriptor); server.svr_sp = sp; server.svr_conn = SERVER_CONNECTION(serp); nserp = server_alloc(&server); if( SC_IS_INTERNAL( scp ) ) { SC_INTERNAL(scp, nserp); } else { exec_server(nserp); } }
static void /* handle console destruction */ free_stream(uintptr_t handle) { IOSTREAM *s = (IOSTREAM*) handle; Sclose(s); }
/* * This function always runs in a forked process. */ idresult_e log_remote_user( const struct server *serp, unsigned timeout ) { static char buf[ IBUFSIZE ] ; int cc ; union xsockaddr sin_local, sin_remote, sin_contact, sin_bind; volatile unsigned local_port; volatile unsigned remote_port; int sd ; socklen_t sin_len ; char *p ; const char *func = "log_remote_user" ; if ( timeout && signal( SIGALRM, sigalrm_handler ) == SIG_ERR ) { msg( LOG_ERR, func, "signal: %m" ) ; return( IDR_ERROR ) ; } /* * Determine local and remote addresses */ sin_len = sizeof( sin_local ) ; if ( getsockname( SERVER_FD( serp ), &sin_local.sa, &sin_len ) == -1 ) { msg( LOG_ERR, func, "(%d) getsockname: %m", getpid() ) ; return( IDR_ERROR ) ; } if ( CONN_XADDRESS( SERVER_CONNECTION( serp ) ) == NULL ) { /* * This shouldn't happen since identification only works for * connection-based services. */ msg( LOG_ERR, func, "connection has no address" ) ; return( IDR_ERROR ) ; } CLEAR( sin_contact ); sin_remote = *CONN_XADDRESS( SERVER_CONNECTION( serp ) ) ; sin_contact = sin_remote; memcpy( &sin_bind, &sin_local, sizeof(sin_bind) ) ; local_port = 0; remote_port = 0; if( sin_remote.sa.sa_family == AF_INET ) { local_port = ntohs( sin_local.sa_in6.sin6_port ) ; remote_port = ntohs( sin_remote.sa_in6.sin6_port ) ; sin_contact.sa_in6.sin6_port = htons( IDENTITY_SERVICE_PORT ) ; sin_bind.sa_in.sin_port = 0 ; } else if( sin_remote.sa.sa_family == AF_INET6 ) { local_port = ntohs( sin_local.sa_in.sin_port ) ; remote_port = ntohs( sin_remote.sa_in.sin_port ) ; sin_contact.sa_in.sin_port = htons( IDENTITY_SERVICE_PORT ) ; sin_bind.sa_in6.sin6_port = 0 ; } /* * Create a socket, bind it, and set the close-on-exec flag on the * descriptor. We set the flag in case we are called as part of a * successful attempt to start a server (i.e. execve will follow). * The socket must be bound to the receiving address or ident might * fail for multi-homed hosts. */ sd = socket( sin_remote.sa.sa_family, SOCK_STREAM, 0 ) ; if ( sd == -1 ) { msg( LOG_ERR, func, "socket creation: %m" ) ; return( IDR_ERROR ) ; } if ( bind(sd, &sin_bind.sa, sizeof(sin_bind.sa)) == -1 ) { msg( LOG_ERR, func, "socket bind: %m" ) ; (void) Sclose( sd ) ; return( IDR_ERROR ) ; } if ( fcntl( sd, F_SETFD, FD_CLOEXEC ) == -1 ) { msg( LOG_ERR, func, "fcntl F_SETFD: %m" ) ; (void) Sclose( sd ) ; return( IDR_ERROR ) ; } if ( timeout ) { if ( sigsetjmp( env, 1 ) == 0 ) START_TIMER( timeout ) ; else { Sclose( sd ) ; return( IDR_TIMEDOUT ) ; } } if ( connect( sd, &sin_contact.sa, sizeof( sin_contact ) ) == -1 ) { if ( timeout ) { STOP_TIMER() ; signal ( SIGALRM, SIG_DFL ) ; } Sclose( sd ); return( IDR_NOSERVER ) ; } cc = strx_nprint( buf, sizeof( buf ), "%d,%d\r\n", remote_port, local_port ) ; if ( write_buf( sd, buf, cc ) == FAILED ) { if ( timeout ) { STOP_TIMER() ; signal ( SIGALRM, SIG_DFL ) ; } Sclose( sd ); return( IDR_ERROR ) ; } p = get_line( sd, buf, sizeof( buf ) ) ; if ( timeout ) { STOP_TIMER() ; signal ( SIGALRM, SIG_DFL ) ; } if ( p == NULL ) { Sclose( sd ); return( IDR_RESPERR ) ; } /* * Verify that the received line is OK */ if ( ( p = verify_line( buf, local_port, remote_port ) ) == NULL ) { msg(LOG_ERR, func, "Bad line received from identity server at %s: %s", xaddrname( &sin_remote ), buf ) ; Sclose( sd ); return( IDR_BADRESP ) ; } svc_logprint( SERVER_CONNSERVICE( serp ), USERID_ENTRY, "%s", p ) ; return( IDR_OK ) ; }
/* * This function is invoked in a forked process to run a server. * If the service is internal the appropriate function is invoked * otherwise the server program is exec'ed. * This function also logs the remote user id if appropriate */ void child_process( struct server *serp ) { struct service *sp = SERVER_SERVICE( serp ) ; connection_s *cp = SERVER_CONNECTION( serp ) ; struct service_config *scp = SVC_CONF( sp ) ; const char *func = "child_process" ; signal_default_state(); if ((signals_pending[0] >= 0 && Sclose(signals_pending[0])) || (signals_pending[1] >= 0 && Sclose(signals_pending[1]))) { msg(LOG_ERR, func, "Failed to close the signal pipe: %m"); _exit(1); } signals_pending[0] = -1; signals_pending[1] = -1; Sclose(0); Sclose(1); Sclose(2); #ifdef DEBUG_SERVER if ( debug.on ) { msg( LOG_DEBUG, func, "Process %d is sleeping", getpid() ) ; sleep( 10 ) ; } #endif if ( ! SC_IS_INTERCEPTED( scp ) ) { set_credentials( scp ) ; if ( SC_SPECIFIED( scp, A_NICE ) ) (void) nice( SC_NICE( scp ) ) ; } if ( svc_child_access_control(sp, cp) != OK ) exit(0); if ( SERVER_LOGUSER( serp ) ) { unsigned timeout ; idresult_e result ; /* * We use LOGUSER_SUCCESS_TIMEOUT unless the service requires * identification, in which case we use an infinite timeout */ timeout = SC_MUST_IDENTIFY( scp ) ? 0 : LOGUSER_SUCCESS_TIMEOUT ; result = log_remote_user( serp, timeout ) ; if ( result != IDR_OK && SC_MUST_IDENTIFY( scp ) ) { svc_logprint( sp, NOID_ENTRY, "%s %s", conn_addrstr( SERVER_CONNECTION( serp ) ), idresult_explain( result ) ) ; _exit( 0 ) ; } } #ifdef HAVE_SESSIONCREATE if ( scp->sc_sessioncreate == YES ) { if ( SessionCreate(0, sessionHasTTY|sessionIsRemote) != noErr ) svc_logprint( sp, "SessionCreate", "SessionCreate() failed!" ); } #endif /* this is where the server gets executed -bbraun */ if ( ! SC_IS_INTERNAL( scp ) ) { if( scp->sc_redir_addr != NULL ) { redir_handler( serp ); } else { #if defined(HAVE_SETENV) char buff[1024]; strx_sprint(buff, sizeof(buff)-1, "REMOTE_HOST=%s", conn_addrstr(cp)); if( env_addstr(SC_ENV(scp)->env_handle, buff) != ENV_OK ) { msg( LOG_ERR, func, "Error adding REMOTE_HOST variable for %s: %m", SC_NAME(scp) ); _exit( 1 ) ; } #endif exec_server( serp ) ; } } else { char name[ 180 ] ; /* * We don't bother to disassociate from the controlling terminal * (we have a controlling terminal only if debug.on is TRUE) * * Also, for interceptor processes, we give them the name: * <program_name> <service-id> interceptor */ if ( SC_IS_INTERCEPTED( scp ) ) strx_print( INT_NULL, name, sizeof( name ) - 1, "%s %s interceptor", program_name, SC_ID( scp ) ) ; else { int namelen = sizeof( name ) - 1 ; /* leave space for the NUL */ char host[NI_MAXHOST]; size_t hostlen = NI_MAXHOST; socklen_t addrlen = 0; union xsockaddr *sinp = CONN_XADDRESS(SERVER_CONNECTION(serp)); int len; if( sinp == NULL ) exit(0); if( SC_IPV6(scp) ) addrlen = sizeof(struct sockaddr_in6); else if( SC_IPV4(scp) ) addrlen = sizeof(struct sockaddr_in); len = strx_nprint(name, namelen, "(%s service) %s", program_name, SC_ID( scp ) ) ; if( getnameinfo( SA(sinp), addrlen, host, hostlen, NULL, 0, 0) != 0 ) strcpy(host, "unknown"); if ( SC_IPV6(scp) && SC_ACCEPTS_CONNECTIONS( scp ) && !IN6_IS_ADDR_UNSPECIFIED(&sinp->sa_in6.sin6_addr) ) strx_print( INT_NULL, &name[ len ], namelen - len, " %s" , host ) ; if ( SC_IPV4(scp) && SC_ACCEPTS_CONNECTIONS( scp ) ) strx_print( INT_NULL, &name[ len ], namelen - len, " %s", host ) ; } rename_process( name ) ; SVC_INTERNAL( sp, serp ) ; } _exit( 0 ) ; /* NOTREACHED */ }
/* * This function is running in the new process */ void exec_server( const struct server *serp ) { const struct service_config *scp = SVC_CONF( SERVER_SERVICE( serp ) ) ; struct rlimit rl ; int fd ; int descriptor = SERVER_FD( serp ) ; const char *server = SC_SERVER( scp ) ; const char *func = "exec_server" ; /* * The following code solves a problem with post-version-4.3 * Ultrix systems (the bug was reported, and a fix was provided by * [email protected]; a slightly modified version of this * fix is included here). * * If this is a 'nowait' service, we pass the service descriptor * to the server. Note that we have set the close-on-exec flag * on all service descriptors. It is unclear whether the dup2() * will create a descriptor with the close-on-exec flag set, * so we explicitly clear the flag (since we are doing this * after the fork, it does not affect the descriptor of the * parent process). */ if ( fcntl( descriptor, F_SETFD, 0 ) == -1 ) msg( LOG_WARNING, func, "fcntl( %d, clear close-on-exec ) failed: %m", descriptor ) ; if ( debug.on ) msg( LOG_DEBUG, func, "duping %d", descriptor ) ; for ( fd = 0 ; fd <= MAX_PASS_FD ; fd++ ) { if ( dup2( descriptor, fd ) == -1 ) { msg( LOG_ERR, func, "dup2( %d, %d ) failed: %m", descriptor, fd ) ; _exit( 1 ) ; } } #ifdef RLIMIT_NOFILE rl.rlim_max = ps.ros.orig_max_descriptors ; rl.rlim_cur = ps.ros.max_descriptors ; (void) setrlimit( RLIMIT_NOFILE, &rl ) ; #endif #ifdef RLIMIT_AS if (SC_RLIM_AS (scp)) { rl.rlim_cur = SC_RLIM_AS( scp ); rl.rlim_max = SC_RLIM_AS( scp ); (void) setrlimit( RLIMIT_AS, &rl ); } #endif #ifdef RLIMIT_CPU if (SC_RLIM_CPU (scp)) { rl.rlim_cur = SC_RLIM_CPU( scp ); rl.rlim_max = SC_RLIM_CPU( scp ); (void) setrlimit( RLIMIT_CPU, &rl ); } #endif #ifdef RLIMIT_DATA if (SC_RLIM_DATA (scp)) { rl.rlim_cur = SC_RLIM_DATA( scp ); rl.rlim_max = SC_RLIM_DATA( scp ); (void) setrlimit( RLIMIT_DATA, &rl ); } #endif #ifdef RLIMIT_RSS if (SC_RLIM_RSS (scp)) { rl.rlim_cur = SC_RLIM_RSS( scp ); rl.rlim_max = SC_RLIM_RSS( scp ); (void) setrlimit( RLIMIT_RSS, &rl ); } #endif #ifdef RLIMIT_STACK if (SC_RLIM_STACK (scp)) { rl.rlim_cur = SC_RLIM_STACK( scp ); rl.rlim_max = SC_RLIM_STACK( scp ); (void) setrlimit( RLIMIT_STACK, &rl ); } #endif (void) Sclose( descriptor ) ; #ifndef solaris no_control_tty() ; #endif msg_suspend() ; (void) execve( server, SC_SERVER_ARGV( scp ), env_getvars( SC_ENV( scp )->env_handle ) ) ; /* * The exec failed. Log the error and exit. */ msg_resume() ; msg( LOG_ERR, func, "execv( %s ) failed: %m", server ) ; _exit( 0 ) ; }
/* * Activate a service. */ status_e svc_activate( struct service *sp ) { struct service_config *scp = SVC_CONF( sp ) ; status_e status ; const char *func = "svc_activate" ; /* No activation for MUXCLIENTS. */ if (SC_IS_MUXCLIENT( scp )) { return( OK ); } if( SC_IPV4( scp ) ) { SVC_FD(sp) = socket( AF_INET, SC_SOCKET_TYPE( scp ), SC_PROTOVAL( scp ) ) ; } else if( SC_IPV6( scp ) ) { SVC_FD(sp) = socket( AF_INET6, SC_SOCKET_TYPE( scp ), SC_PROTOVAL( scp ) ) ; } if ( SVC_FD(sp) == -1 ) { msg( LOG_ERR, func, "socket creation failed (%m). service = %s", SC_ID( scp ) ) ; return( FAILED ) ; } if ( set_fd_modes( sp ) == FAILED ) { (void) Sclose( SVC_FD(sp) ) ; return( FAILED ) ; } #ifndef NO_RPC if ( SC_IS_RPC( scp ) ) status = activate_rpc( sp ) ; else #endif /* ! NO_RPC */ status = activate_normal( sp ) ; if ( status == FAILED ) { (void) Sclose( SVC_FD(sp) ) ; return( FAILED ) ; } #ifdef HAVE_MDNS xinetd_mdns_register(scp); #endif if ( log_start( sp, &SVC_LOG(sp) ) == FAILED ) { deactivate( sp ) ; return( FAILED ) ; } /* * Initialize the service data */ SVC_RUNNING_SERVERS(sp) = SVC_RETRIES(sp) = 0 ; if ( SC_MUST_LISTEN( scp ) ) (void) listen( SVC_FD(sp), LISTEN_BACKLOG ) ; ps.rws.descriptors_free-- ; SVC_STATE(sp) = SVC_ACTIVE ; FD_SET( SVC_FD(sp), &ps.rws.socket_mask ) ; if ( SVC_FD(sp) > ps.rws.mask_max ) ps.rws.mask_max = SVC_FD(sp) ; ps.rws.active_services++ ; ps.rws.available_services++ ; return( OK ) ; }