void sigwinch_handler(int signo) { // TODO (std_string) : may be some reaction clear_input_handler(); install_input_handler(); install_signal_handlers(); }
void sigtstp_handler(int signo) { // TODO (std_string) : may be use rl_echo_signal_char(int) std::cout << "^Z" << std::endl; cstate.set_execution_state(EX_FINISH); install_signal_handlers(); }
int main(int argc, char **argv) { char *command_name; rlwrap_command_line = unsplit_with(argc, argv, " "); init_completer(); /* Harvest options and leave optind pointing to first non-option argument: */ command_name = read_options_and_command_name(argc, argv); /* by now, optind points to slave <command>, and &argv[optind] is <command>'s argv. Remember slave command line: */ command_line = unsplit_with(argc - optind, argv, " "); /* if stdin is not a tty, just execute <command>: */ if (!isatty(STDIN_FILENO) && execvp(argv[optind], &argv[optind]) < 0) myerror(FATAL|USE_ERRNO, "Cannot execute %s", argv[optind]); init_rlwrap(rlwrap_command_line); install_signal_handlers(); block_all_signals(); fork_child(command_name, argv); /* this will unblock most signals most of the time */ if (filter_command) spawn_filter(filter_command); main_loop(); return 42; /* The Answer, but, sadly, we'll never get there.... */ }
int main(int argc, char *argv[]) { int nproc; /* * For each of argv[1] to argv[argc - 1], * create a new child process, add it to the process list. */ nproc = 0; /* number of proccesses goes here */ /* Wait for all children to raise SIGSTOP before exec()ing. */ wait_for_ready_children(nproc); /* Install SIGALRM and SIGCHLD handlers. */ install_signal_handlers(); if (nproc == 0) { fprintf(stderr, "Scheduler: No tasks. Exiting...\n"); exit(1); } /* loop forever until we exit from inside a signal handler. */ while (pause()) ; /* Unreachable */ fprintf(stderr, "Internal error: Reached unreachable point\n"); return 1; }
void sigint_handler(int signo) { // ^C already is shown on screen std::cout << std::endl; interrupt_command(cstate.get_socketd()); install_signal_handlers(); }
int main_loop() { install_signal_handlers(); for(;;) { int pid, status; pid = wait(&status); if ((pid == -1) && (errno != EINTR)) { perror("wait error"); return 255; } else if (pid == child_pid) { if (WIFEXITED(status)) { // normal exit return WEXITSTATUS(status); } else if (WIFSIGNALED(status)) { // killed int sig = WTERMSIG(status); fprintf(stderr, "killed by signal %d (%s)\n", sig, strsignal(sig)); return 255; } else { // unreachable fprintf(stderr, "bad exit status"); fflush(stderr); abort(); } } } }
// // TODO: Include your function header here // int main(int argc, char *argv[]) { int retcode = EXIT_SUCCESS; prog_options_t my_opt; // read program options if (get_options(argc, argv, &my_opt) == 0) { print_usage(my_opt.progname); exit(EXIT_FAILURE); } /* end if */ // set the time zone (TZ) to GMT in order to // ignore any other local time zone that would // interfere with correct time string parsing setenv("TZ", "GMT", 1); tzset(); // do some checks and initialisations... open_logfile(&my_opt); install_signal_handlers(); init_logging_semaphore(); // TODO: start the proxy server and handle connections... // here, as an example, show how to interact with the // condition set by the signal handler above printf("[%d] Starting proxy server '%s'...\n", getpid(), my_opt.progname); server_running = true; while(server_running) { pause(); } /* end while */ printf("[%d] Good Bye...\n", getpid()); exit(retcode); } /* end of main */
int main( int argc, char *argv[] ) { int server = 0; //listen用socket char *port = NULL; char *docroot; int opt; while ((opt = getopt_long(argc, argv, "", longopts, NULL)) != -1) { switch(opt) { case 0: break; case 'c': break; case 'p': port = optarg; break; case 'h': fprintf(stdout, USAGE, argv[0]); exit(0); case '?': fprintf(stderr, USAGE, argv[0]); exit(1); } } if(optind != argc - 1) { fprintf(stderr, USAGE, argv[0]); exit(1); } /* ドキュメントのrootディレクトリを設定 */ docroot = argv[optind]; /* シグナル捕捉の設定 */ install_signal_handlers(); /* listenソケットの作成 */ server = listen_socket(port); if(!debug_mode) { openlog(SERVER_NAME, LOG_PID|LOG_NDELAY, LOG_DAEMON); /* デーモンプロセスになる */ become_daemon(); } server_main(server, docroot); return 0; }
int main(int argc, char **argv) { GtkWidget *window, *button, *textview, *vbox; GtkWidget *socket, *plug, *socket_box; unsigned long kb_xid; gtk_init (&argc, &argv); install_signal_handlers(); kb_xid = launch_keyboard(); if (!kb_xid) { perror ("### 'matchbox-keyboard --xid', failed to return valid window ID. ### "); exit(-1); } /* Window */ window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size (GTK_WINDOW (window), 640, 480); gtk_container_set_border_width (GTK_CONTAINER (window), 10); g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (widget_destroy), NULL); /* Container and textview */ vbox = gtk_vbox_new(FALSE, 5); gtk_container_add (GTK_CONTAINER (window), vbox); textview = gtk_text_view_new(); gtk_box_pack_start (GTK_BOX(vbox), textview, TRUE, TRUE, 2); /* Socket ( XEMBED ) stuff */ socket_box = gtk_event_box_new (); gtk_widget_show (socket_box); socket = gtk_socket_new (); gtk_container_add (GTK_CONTAINER (socket_box), socket); gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET(socket_box), TRUE, TRUE, 0); gtk_socket_add_id(GTK_SOCKET(socket), kb_xid); /* FIXME: handle "plug-added" & "plug-removed" signals for socket */ gtk_widget_show_all (window); gtk_main (); return 0; }
int main(int argc, char *argv[]) { int server; char *port = NULL; char *docroot; int do_chroot = 0; char *user = NULL; char *group = NULL; int opt; while ((opt = getopt_long(argc, argv, "p:h:", longopts, NULL)) != -1) { switch (opt) { case 0: break; case 'c': do_chroot = 1; break; case 'u': user = optarg; break; case 'g': group = optarg; break; case 'p': port = optarg; break; case 'h': fprintf(stdout, USAGE, argv[0]); exit(0); case '?': fprintf(stderr, USAGE, argv[0]); exit(1); } } if (optind != argc - 1) { fprintf(stderr, USAGE, argv[0]); exit(1); } docroot = argv[optind]; if (do_chroot) { setup_environment(docroot, user, group); docroot = ""; } install_signal_handlers(); server = listen_socket(port); if (!debug_mode) { openlog(SERVER_NAME, LOG_PID|LOG_NDELAY, LOG_DAEMON); become_daemon(); } server_main(server, docroot); exit(0); }
int main(int argc, char *argv[]) { int sockfd; int retcode = EXIT_SUCCESS; // read program options if (get_options(argc, argv, &my_opt) == 0) { print_usage(my_opt.progname); exit(EXIT_FAILURE); } /* end if */ // set the time zone (TZ) to GMT in order to // ignore any other local time zone that would // interfere with correct time string parsing setenv("TZ", "GMT", 1); tzset(); /* printf("Server Port: %d\n", my_opt.server_port); //printf("Server Address: %d\n", my_opt.server_addr); printf("Progname: %s\n", my_opt.progname); printf("Root Dir: %s\n", my_opt.root_dir); printf("Log File: %s\n", my_opt.log_filename); */ // do some checks and initialisations... open_logfile(&my_opt); check_root_dir(&my_opt); install_signal_handlers(); init_logging_semaphore(); // TODO: start the server and handle clients... // here, as an example, show how to interact with the // condition set by the signal handler above //printf("[%d] Starting server '%s'...\n", getpid(), my_opt.progname); server_running = true; prog_options_t *opt = &my_opt; struct sockaddr_in* struct_port = (struct sockaddr_in*) opt->server_addr->ai_addr; sockfd = server_init(ntohs(struct_port->sin_port)); //printf("Port: %i \n", sockfd); while(server_running) { client_connection(sockfd); //pause(); } /* end while */ printf("[%d] Good Bye...\n", getpid()); exit(retcode); } /* end of main */
int main(int argc, char *argv[]) { pid_t p; int i; /* * For each of argv[1] to argv[argc - 1], * create a new child process, add it to the process list. */ current = 0; /* current proccess number goes here */ nprog = argc - 1; /* number of proccesses goes here */ childid = malloc((nprog)*sizeof(int)); alive = malloc((nprog)*sizeof(int)); for (i=0; i < nprog; i++){ printf("forking..%d %d\n", argc, i); p = fork(); //if (p<0)... if (p == 0){ do_child(argv[i+1]); } else{ childid[i] = (int) p; alive[i] = 1; } } /* Wait for all children to raise SIGSTOP before exec()ing. */ wait_for_ready_children(nprog); /* Install SIGALRM and SIGCHLD handlers. */ install_signal_handlers(); if (nprog == 0) { fprintf(stderr, "Scheduler: No tasks. Exiting...\n"); exit(1); } else{ alarm(SCHED_TQ_SEC); kill(childid[0], SIGCONT); } /* loop forever until we exit from inside a signal handler. */ while (pause()) ; /* Unreachable */ fprintf(stderr, "Internal error: Reached unreachable point\n"); return 1; }
/* * Read parameters and fork off children that abuse first mmap and then * io_setup in the hopes of causing an oops. */ int main(int argc, char *argv[]) { int i, x, forks, mmap_calls, iosetup_calls; if (argc < 4) { printf("Usage: %s forks mmap_calls iosetup_calls\n", argv[0]); return 1; } forks = atoi(argv[1]); mmap_calls = atoi(argv[2]); iosetup_calls = atoi(argv[3]); printf("%.5d: forks = %d mmaps = %d iosetups = %d\n", getpid(), forks, mmap_calls, iosetup_calls); for (i = 0; i < forks; i++) { x = fork(); if (x == 0) { /* new proc, so start pounding */ printf("%.5d: initializing.\n", getpid()); seed_random(); install_signal_handlers(); printf("%.5d: creating mmaps.\n", getpid()); mmap_pound(mmap_calls); examine_vmsize(); printf("%.5d: calling iosetup..\n", getpid()); iosetup_pound(iosetup_calls); printf("%.5d: done pounding.\n", getpid()); return 0; } else { printf("%.5d: forked pid %.5d.\n", getpid(), x); } } printf("%.5d: waiting for children.\n", getpid()); for (i = 0; i < forks; i++) { wait(NULL); } printf("%.5d: exiting.\n", getpid()); return 0; }
int main(int argc, char *argv[]) { int retcode = EXIT_SUCCESS; prog_options_t my_opt; // read program options if (get_options(argc, argv, &my_opt) == 0) { print_usage(my_opt.progname); exit(EXIT_FAILURE); } /* end if */ // set the time zone (TZ) to GMT in order to // ignore any other local time zone that would // interfere with correct time string parsing setenv("TZ", "GMT", 1); tzset(); // do some checks and initialisations... open_logfile(&my_opt); check_root_dir(&my_opt); install_signal_handlers(); init_logging_semaphore(); // get root_dir to handle it later in child process char* root_dir = my_opt.root_dir; // start the server and create socket printf("[%d] Starting server '%s'...\n", getpid(), my_opt.progname); int accepting_socket = passive_tcp(my_opt.server_port, 5); struct sockaddr_in from_client; server_running = true; while(server_running) { socklen_t from_client_len = sizeof(from_client); // Accept new Client int listening_socket = accept(accepting_socket, (struct sockaddr *) &from_client, &from_client_len); accept_client(accepting_socket, listening_socket, root_dir); } /* end while */ printf("[%d] Good Bye...\n", getpid()); exit(retcode); } /* end of main */
int main ( int argc, char *argv[] ) { dbg( "argc=%d, argv=%p\n", argc, argv ); usage( argc, argv ); chk_doc_root( argv[1] ); install_signal_handlers(); service( stdin, stdout, argv[1] ); return 0; }
int main(int argc, char *argv[]) { int debug = 0; if (!seed_random()) { return 1; } if (argc > 1 && strcmp(argv[1], "-d") == 0) { debug = 1; } /* FILE *fp = fopen("/dev/tty", "w"); fprintf(fp, "randasys process group is %d\n", getpgrp()); fclose(fp); */ install_signal_handlers(); while(1) { callnum = find_syscall(); args[0] = get_randnum(0, ULONG_MAX); args[1] = get_randnum(0, ULONG_MAX); args[2] = get_randnum(0, ULONG_MAX); args[3] = get_randnum(0, ULONG_MAX); args[4] = get_randnum(0, ULONG_MAX); args[5] = get_randnum(0, ULONG_MAX); if (debug) { printf("syscall(%d, 0x%X, 0x%X, 0x%X, 0x%X, 0x%X, 0x%X); \r", callnum, args[0], args[1], args[2], args[3], args[4], args[5]); fflush(stdout); } syscall(callnum, args[0], args[1], args[2], args[3], args[4], args[5]); } return 0; }
int main(int argc, char **argv) { if (argc < 2) { print_usage(); return 1; } install_signal_handlers(); lua_State* L = launch_lua("./include/main.lua"); if (!L) { return -1; } lua_pushstring(L, "master"); for (int i = 0; i < argc; i++) { lua_pushstring(L, argv[i]); } if (lua_pcall(L, argc + 1, 0, 0)) { printf("Lua error: %s\n", lua_tostring(L, -1)); return -1; } return 0; }
int main(int argc, char **argv) { char *command_name; init_completer(); command_name = read_options_and_command_name(argc, argv); /* by now, optind points to <command>, and &argv[optind] is <command>'s argv */ if (!isatty(STDIN_FILENO) && execvp(argv[optind], &argv[optind]) < 0) /* if stdin is not a tty, just execute <command> */ myerror("Cannot execute %s", argv[optind]); init_rlwrap(); install_signal_handlers(); block_all_signals(); fork_child(command_name, argv); if (filter_command) spawn_filter(filter_command); main_loop(); return 42; /* not reached, but some compilers are unhappy without this ... */ }
int main(int argc, char *argv[]) { int i; int debug = 0, zero_mode = 0; if (!seed_random()) { return 1; } for (i = 1; i < argc; i++) { if (!strcmp(argv[i], "-d")) debug = 1; else if (!strcmp(argv[i], "-z")) zero_mode = 1; } memset(args, 0, sizeof(unsigned long) * 6); install_signal_handlers(); while (1) { callnum = find_syscall(); if (!zero_mode) get_big_randnum(&args[0], sizeof(unsigned long) * 6); if (debug) { printf("syscall(%lu, 0x%lX, 0x%lX, 0x%lX, 0x%lX, " "0x%lX, 0x%lX); \n", callnum, args[0], args[1], args[2], args[3], args[4], args[5]); fflush(stdout); } syscall(callnum, args[0], args[1], args[2], args[3], args[4], args[5]); } return 0; }
int main(int argc, char *argv[]) { srvr_sockaddr_union_t me; curl_socket_t sock = CURL_SOCKET_BAD; curl_socket_t msgsock = CURL_SOCKET_BAD; int wrotepidfile = 0; char *pidname= (char *)".sockfilt.pid"; bool juggle_again; int rc; int error; int arg=1; enum sockmode mode = PASSIVE_LISTEN; /* default */ const char *addr = NULL; while(argc>arg) { if(!strcmp("--version", argv[arg])) { printf("sockfilt IPv4%s\n", #ifdef ENABLE_IPV6 "/IPv6" #else "" #endif ); return 0; } else if(!strcmp("--verbose", argv[arg])) { verbose = TRUE; arg++; } else if(!strcmp("--pidfile", argv[arg])) { arg++; if(argc>arg) pidname = argv[arg++]; } else if(!strcmp("--logfile", argv[arg])) { arg++; if(argc>arg) serverlogfile = argv[arg++]; } else if(!strcmp("--ipv6", argv[arg])) { #ifdef ENABLE_IPV6 ipv_inuse = "IPv6"; use_ipv6 = TRUE; #endif arg++; } else if(!strcmp("--ipv4", argv[arg])) { /* for completeness, we support this option as well */ #ifdef ENABLE_IPV6 ipv_inuse = "IPv4"; use_ipv6 = FALSE; #endif arg++; } else if(!strcmp("--bindonly", argv[arg])) { bind_only = TRUE; arg++; } else if(!strcmp("--port", argv[arg])) { arg++; if(argc>arg) { char *endptr; unsigned long ulnum = strtoul(argv[arg], &endptr, 10); if((endptr != argv[arg] + strlen(argv[arg])) || ((ulnum != 0UL) && ((ulnum < 1025UL) || (ulnum > 65535UL)))) { fprintf(stderr, "sockfilt: invalid --port argument (%s)\n", argv[arg]); return 0; } port = curlx_ultous(ulnum); arg++; } } else if(!strcmp("--connect", argv[arg])) { /* Asked to actively connect to the specified local port instead of doing a passive server-style listening. */ arg++; if(argc>arg) { char *endptr; unsigned long ulnum = strtoul(argv[arg], &endptr, 10); if((endptr != argv[arg] + strlen(argv[arg])) || (ulnum < 1025UL) || (ulnum > 65535UL)) { fprintf(stderr, "sockfilt: invalid --connect argument (%s)\n", argv[arg]); return 0; } connectport = curlx_ultous(ulnum); arg++; } } else if(!strcmp("--addr", argv[arg])) { /* Set an IP address to use with --connect; otherwise use localhost */ arg++; if(argc>arg) { addr = argv[arg]; arg++; } } else { puts("Usage: sockfilt [option]\n" " --version\n" " --verbose\n" " --logfile [file]\n" " --pidfile [file]\n" " --ipv4\n" " --ipv6\n" " --bindonly\n" " --port [port]\n" " --connect [port]\n" " --addr [address]"); return 0; } } #ifdef WIN32 win32_init(); atexit(win32_cleanup); setmode(fileno(stdin), O_BINARY); setmode(fileno(stdout), O_BINARY); setmode(fileno(stderr), O_BINARY); #endif install_signal_handlers(); #ifdef ENABLE_IPV6 if(!use_ipv6) #endif sock = socket(AF_INET, SOCK_STREAM, 0); #ifdef ENABLE_IPV6 else sock = socket(AF_INET6, SOCK_STREAM, 0); #endif if(CURL_SOCKET_BAD == sock) { error = SOCKERRNO; logmsg("Error creating socket: (%d) %s", error, strerror(error)); write_stdout("FAIL\n", 5); goto sockfilt_cleanup; } if(connectport) { /* Active mode, we should connect to the given port number */ mode = ACTIVE; #ifdef ENABLE_IPV6 if(!use_ipv6) { #endif memset(&me.sa4, 0, sizeof(me.sa4)); me.sa4.sin_family = AF_INET; me.sa4.sin_port = htons(connectport); me.sa4.sin_addr.s_addr = INADDR_ANY; if (!addr) addr = "127.0.0.1"; Curl_inet_pton(AF_INET, addr, &me.sa4.sin_addr); rc = connect(sock, &me.sa, sizeof(me.sa4)); #ifdef ENABLE_IPV6 } else { memset(&me.sa6, 0, sizeof(me.sa6)); me.sa6.sin6_family = AF_INET6; me.sa6.sin6_port = htons(connectport); if (!addr) addr = "::1"; Curl_inet_pton(AF_INET6, addr, &me.sa6.sin6_addr); rc = connect(sock, &me.sa, sizeof(me.sa6)); } #endif /* ENABLE_IPV6 */ if(rc) { error = SOCKERRNO; logmsg("Error connecting to port %hu: (%d) %s", connectport, error, strerror(error)); write_stdout("FAIL\n", 5); goto sockfilt_cleanup; } logmsg("====> Client connect"); msgsock = sock; /* use this as stream */ } else { /* passive daemon style */ sock = sockdaemon(sock, &port); if(CURL_SOCKET_BAD == sock) { write_stdout("FAIL\n", 5); goto sockfilt_cleanup; } msgsock = CURL_SOCKET_BAD; /* no stream socket yet */ } logmsg("Running %s version", ipv_inuse); if(connectport) logmsg("Connected to port %hu", connectport); else if(bind_only) logmsg("Bound without listening on port %hu", port); else logmsg("Listening on port %hu", port); wrotepidfile = write_pidfile(pidname); if(!wrotepidfile) { write_stdout("FAIL\n", 5); goto sockfilt_cleanup; } do { juggle_again = juggle(&msgsock, sock, &mode); } while(juggle_again); sockfilt_cleanup: if((msgsock != sock) && (msgsock != CURL_SOCKET_BAD)) sclose(msgsock); if(sock != CURL_SOCKET_BAD) sclose(sock); if(wrotepidfile) unlink(pidname); restore_signal_handlers(); if(got_exit_signal) { logmsg("============> sockfilt exits with signal (%d)", exit_signal); /* * To properly set the return status of the process we * must raise the same signal SIGINT or SIGTERM that we * caught and let the old handler take care of it. */ raise(exit_signal); } logmsg("============> sockfilt quits"); return 0; }
int main(int argc, char *argv[]) { struct sockaddr_in me; #ifdef ENABLE_IPV6 struct sockaddr_in6 me6; #endif /* ENABLE_IPV6 */ curl_socket_t sock = CURL_SOCKET_BAD; curl_socket_t msgsock = CURL_SOCKET_BAD; int wrotepidfile = 0; int flag; unsigned short port = DEFAULT_PORT; char *pidname= (char *)".rtsp.pid"; struct httprequest req; int rc; int error; int arg=1; long pid; while(argc>arg) { if(!strcmp("--version", argv[arg])) { printf("rtspd IPv4%s" "\n" , #ifdef ENABLE_IPV6 "/IPv6" #else "" #endif ); return 0; } else if(!strcmp("--pidfile", argv[arg])) { arg++; if(argc>arg) pidname = argv[arg++]; } else if(!strcmp("--logfile", argv[arg])) { arg++; if(argc>arg) serverlogfile = argv[arg++]; } else if(!strcmp("--ipv4", argv[arg])) { #ifdef ENABLE_IPV6 ipv_inuse = "IPv4"; use_ipv6 = FALSE; #endif arg++; } else if(!strcmp("--ipv6", argv[arg])) { #ifdef ENABLE_IPV6 ipv_inuse = "IPv6"; use_ipv6 = TRUE; #endif arg++; } else if(!strcmp("--port", argv[arg])) { arg++; if(argc>arg) { char *endptr; long lnum = -1; lnum = strtol(argv[arg], &endptr, 10); if((endptr != argv[arg] + strlen(argv[arg])) || (lnum < 1025L) || (lnum > 65535L)) { fprintf(stderr, "rtspd: invalid --port argument (%s)\n", argv[arg]); return 0; } port = (unsigned short)(lnum & 0xFFFFL); arg++; } } else if(!strcmp("--srcdir", argv[arg])) { arg++; if(argc>arg) { path = argv[arg]; arg++; } } else { puts("Usage: rtspd [option]\n" " --version\n" " --logfile [file]\n" " --pidfile [file]\n" " --ipv4\n" " --ipv6\n" " --port [port]\n" " --srcdir [path]"); return 0; } } #ifdef WIN32 win32_init(); atexit(win32_cleanup); #endif install_signal_handlers(); pid = (long)getpid(); #ifdef ENABLE_IPV6 if(!use_ipv6) #endif sock = socket(AF_INET, SOCK_STREAM, 0); #ifdef ENABLE_IPV6 else sock = socket(AF_INET6, SOCK_STREAM, 0); #endif if(CURL_SOCKET_BAD == sock) { error = SOCKERRNO; logmsg("Error creating socket: (%d) %s", error, strerror(error)); goto server_cleanup; } flag = 1; if (0 != setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *)&flag, sizeof(flag))) { error = SOCKERRNO; logmsg("setsockopt(SO_REUSEADDR) failed with error: (%d) %s", error, strerror(error)); goto server_cleanup; } #ifdef ENABLE_IPV6 if(!use_ipv6) { #endif memset(&me, 0, sizeof(me)); me.sin_family = AF_INET; me.sin_addr.s_addr = INADDR_ANY; me.sin_port = htons(port); rc = bind(sock, (struct sockaddr *) &me, sizeof(me)); #ifdef ENABLE_IPV6 } else { memset(&me6, 0, sizeof(me6)); me6.sin6_family = AF_INET6; me6.sin6_addr = in6addr_any; me6.sin6_port = htons(port); rc = bind(sock, (struct sockaddr *) &me6, sizeof(me6)); } #endif /* ENABLE_IPV6 */ if(0 != rc) { error = SOCKERRNO; logmsg("Error binding socket on port %hu: (%d) %s", port, error, strerror(error)); goto server_cleanup; } logmsg("Running %s version on port %d", ipv_inuse, (int)port); /* start accepting connections */ rc = listen(sock, 5); if(0 != rc) { error = SOCKERRNO; logmsg("listen() failed with error: (%d) %s", error, strerror(error)); goto server_cleanup; } /* ** As soon as this server writes its pid file the test harness will ** attempt to connect to this server and initiate its verification. */ wrotepidfile = write_pidfile(pidname); if(!wrotepidfile) goto server_cleanup; for (;;) { msgsock = accept(sock, NULL, NULL); if(got_exit_signal) break; if (CURL_SOCKET_BAD == msgsock) { error = SOCKERRNO; logmsg("MAJOR ERROR: accept() failed with error: (%d) %s", error, strerror(error)); break; } /* ** As soon as this server acepts a connection from the test harness it ** must set the server logs advisor read lock to indicate that server ** logs should not be read until this lock is removed by this server. */ set_advisor_read_lock(SERVERLOGS_LOCK); serverlogslocked = 1; logmsg("====> Client connect"); #ifdef TCP_NODELAY /* * Disable the Nagle algorithm to make it easier to send out a large * response in many small segments to torture the clients more. */ flag = 1; if (setsockopt(msgsock, IPPROTO_TCP, TCP_NODELAY, (void *)&flag, sizeof(flag)) == -1) { logmsg("====> TCP_NODELAY failed"); } #endif /* initialization of httprequest struct is done in get_request(), but due to pipelining treatment the pipelining struct field must be initialized previously to FALSE every time a new connection arrives. */ req.pipelining = FALSE; do { if(got_exit_signal) break; if(get_request(msgsock, &req)) /* non-zero means error, break out of loop */ break; if(prevbounce) { /* bounce treatment requested */ if((req.testno == prevtestno) && (req.partno == prevpartno)) { req.partno++; logmsg("BOUNCE part number to %ld", req.partno); } else { prevbounce = FALSE; prevtestno = -1; prevpartno = -1; } } send_doc(msgsock, &req); if(got_exit_signal) break; if((req.testno < 0) && (req.testno != DOCNUMBER_CONNECT)) { logmsg("special request received, no persistency"); break; } if(!req.open) { logmsg("instructed to close connection after server-reply"); break; } if(req.open) logmsg("=> persistant connection request ended, awaits new request"); /* if we got a CONNECT, loop and get another request as well! */ } while(req.open || (req.testno == DOCNUMBER_CONNECT)); if(got_exit_signal) break; logmsg("====> Client disconnect"); sclose(msgsock); msgsock = CURL_SOCKET_BAD; if(serverlogslocked) { serverlogslocked = 0; clear_advisor_read_lock(SERVERLOGS_LOCK); } if (req.testno == DOCNUMBER_QUIT) break; } server_cleanup: if((msgsock != sock) && (msgsock != CURL_SOCKET_BAD)) sclose(msgsock); if(sock != CURL_SOCKET_BAD) sclose(sock); if(got_exit_signal) logmsg("signalled to die"); if(wrotepidfile) unlink(pidname); if(serverlogslocked) { serverlogslocked = 0; clear_advisor_read_lock(SERVERLOGS_LOCK); } restore_signal_handlers(); if(got_exit_signal) { logmsg("========> %s rtspd (port: %d pid: %ld) exits with signal (%d)", ipv_inuse, (int)port, pid, exit_signal); /* * To properly set the return status of the process we * must raise the same signal SIGINT or SIGTERM that we * caught and let the old handler take care of it. */ raise(exit_signal); } logmsg("========> rtspd quits"); return 0; }
int main(int argc, char *argv[]) { int retcode = EXIT_SUCCESS; prog_options_t my_opt; // read program options if (get_options(argc, argv, &my_opt) == 0) { print_usage(my_opt.progname); exit(EXIT_FAILURE); } /* end if */ // set the time zone (TZ) to GMT in order to // ignore any other local time zone that would // interfere with correct time string parsing setenv("TZ", "GMT", 1); tzset(); // do some checks and initialisations... open_logfile(&my_opt); check_root_dir(&my_opt); install_signal_handlers(); init_logging_semaphore(); // get root_dir to handle it later in child process char* root_dir = my_opt.root_dir; // start the server and create socket print_log("Starting server '%s'...\n", my_opt.progname); int accepting_socket = passive_tcp(my_opt.server_port, 5); if (accepting_socket < 0){ err_print("Error when opening accepting socket!"); exit(-1); } struct sockaddr_in from_client; int req_no = 0; server_running = true; while(server_running) { socklen_t from_client_len = sizeof(from_client); int listening_socket = accept(accepting_socket, (struct sockaddr *) &from_client, &from_client_len); if (listening_socket >= 0){ /* Accept was ok */ ++req_no; pid_t pid = fork(); if (pid == 0) { /* Child Process */ print_log("Process created to handle new request #%d\n", req_no); close(accepting_socket); handle_client(listening_socket, root_dir); exit(0); } else if (pid > 0) { /* Parent Process */ close(listening_socket); } else { /* Fork Failed */ err_print("Could not fork for new request!"); exit(-1); } } /*else { print_log("Accept failed!\n"); } */ } /* end while */ printf("[%d] Good Bye...\n", getpid()); exit(retcode); } /* end of main */
/** * Main * * @param argc Number of command line arguments * @param argv Array with command line arguments * @return 0 on success, non-zero on failure */ int main(int argc, char **argv) { int optc; int opt_index; int verbosity = LL_DEFAULT; int logtype = MCE_LOG_SYSLOG; gint status = EXIT_FAILURE; gboolean show_module_info = FALSE; gboolean daemonflag = FALSE; gboolean systembus = TRUE; gboolean debugmode = FALSE; const char optline[] = "dsTSMDqvhVt:"; struct option const options[] = { { "daemonflag", no_argument, 0, 'd' }, { "force-syslog", no_argument, 0, 's' }, { "force-stderr", no_argument, 0, 'T' }, { "session", no_argument, 0, 'S' }, { "show-module-info", no_argument, 0, 'M' }, { "debug-mode", no_argument, 0, 'D' }, { "quiet", no_argument, 0, 'q' }, { "verbose", no_argument, 0, 'v' }, { "help", no_argument, 0, 'h' }, { "version", no_argument, 0, 'V' }, { "trace", required_argument, 0, 't' }, { 0, 0, 0, 0 } }; /* Initialise support for locales, and set the program-name */ if (init_locales(PRG_NAME) != 0) goto EXIT; /* Parse the command-line options */ while ((optc = getopt_long(argc, argv, optline, options, &opt_index)) != -1) { switch (optc) { case 'd': daemonflag = TRUE; break; case 's': logtype = MCE_LOG_SYSLOG; break; case 'T': logtype = MCE_LOG_STDERR; break; case 'S': systembus = FALSE; break; case 'M': show_module_info = TRUE; break; case 'D': debugmode = TRUE; break; case 'q': if (verbosity > LL_NONE) verbosity--; break; case 'v': if (verbosity < LL_DEBUG) verbosity++; break; case 'h': usage(); exit(EXIT_SUCCESS); case 'V': version(); exit(EXIT_SUCCESS); case 't': if( !mce_enable_trace(optarg) ) exit(EXIT_FAILURE); break; default: usage(); exit(EXIT_FAILURE); } } /* We don't take any non-flag arguments */ if ((argc - optind) > 0) { fprintf(stderr, _("%s: Too many arguments\n" "Try: `%s --help' for more information.\n"), progname, progname); exit(EXIT_FAILURE); } mce_log_open(PRG_NAME, LOG_DAEMON, logtype); mce_log_set_verbosity(verbosity); #ifdef ENABLE_WAKELOCKS /* Since mce enables automatic suspend, we must try to * disable it when mce process exits */ atexit(mce_cleanup_wakelocks); #endif /* Daemonize if requested */ if (daemonflag == TRUE) daemonize(); /* Initialise GType system */ g_type_init(); /* Register a mainloop */ mainloop = g_main_loop_new(NULL, FALSE); /* Signal handlers can be installed once we have a mainloop */ if( !mce_init_signal_pipe() ) { mce_log(LL_CRIT, "Failed to initialise signal pipe"); exit(EXIT_FAILURE); } install_signal_handlers(); /* Initialise subsystems */ /* Get configuration options */ if( !mce_conf_init() ) { mce_log(LL_CRIT, "Failed to initialise configuration options"); exit(EXIT_FAILURE); } /* Initialise D-Bus */ if (mce_dbus_init(systembus) == FALSE) { mce_log(LL_CRIT, "Failed to initialise D-Bus"); mce_log_close(); exit(EXIT_FAILURE); } /* Initialise GConf * pre-requisite: g_type_init() */ if (mce_gconf_init() == FALSE) { mce_log(LL_CRIT, "Cannot connect to default GConf engine"); mce_log_close(); exit(EXIT_FAILURE); } /* Setup all datapipes */ setup_datapipe(&system_state_pipe, READ_WRITE, DONT_FREE_CACHE, 0, GINT_TO_POINTER(MCE_STATE_UNDEF)); setup_datapipe(&master_radio_pipe, READ_WRITE, DONT_FREE_CACHE, 0, GINT_TO_POINTER(0)); setup_datapipe(&call_state_pipe, READ_WRITE, DONT_FREE_CACHE, 0, GINT_TO_POINTER(CALL_STATE_NONE)); setup_datapipe(&call_type_pipe, READ_WRITE, DONT_FREE_CACHE, 0, GINT_TO_POINTER(NORMAL_CALL)); setup_datapipe(&alarm_ui_state_pipe, READ_ONLY, DONT_FREE_CACHE, 0, GINT_TO_POINTER(MCE_ALARM_UI_INVALID_INT32)); setup_datapipe(&submode_pipe, READ_ONLY, DONT_FREE_CACHE, 0, GINT_TO_POINTER(MCE_NORMAL_SUBMODE)); setup_datapipe(&display_state_pipe, READ_WRITE, DONT_FREE_CACHE, 0, GINT_TO_POINTER(MCE_DISPLAY_UNDEF)); setup_datapipe(&display_brightness_pipe, READ_WRITE, DONT_FREE_CACHE, 0, GINT_TO_POINTER(0)); setup_datapipe(&led_brightness_pipe, READ_WRITE, DONT_FREE_CACHE, 0, GINT_TO_POINTER(0)); setup_datapipe(&led_pattern_activate_pipe, READ_ONLY, FREE_CACHE, 0, NULL); setup_datapipe(&led_pattern_deactivate_pipe, READ_ONLY, FREE_CACHE, 0, NULL); setup_datapipe(&key_backlight_pipe, READ_WRITE, DONT_FREE_CACHE, 0, GINT_TO_POINTER(0)); setup_datapipe(&keypress_pipe, READ_ONLY, FREE_CACHE, sizeof (struct input_event), NULL); setup_datapipe(&touchscreen_pipe, READ_ONLY, FREE_CACHE, sizeof (struct input_event), NULL); setup_datapipe(&device_inactive_pipe, READ_WRITE, DONT_FREE_CACHE, 0, GINT_TO_POINTER(FALSE)); setup_datapipe(&lockkey_pipe, READ_ONLY, DONT_FREE_CACHE, 0, GINT_TO_POINTER(0)); setup_datapipe(&keyboard_slide_pipe, READ_ONLY, DONT_FREE_CACHE, 0, GINT_TO_POINTER(0)); setup_datapipe(&lid_cover_pipe, READ_ONLY, DONT_FREE_CACHE, 0, GINT_TO_POINTER(0)); setup_datapipe(&lens_cover_pipe, READ_ONLY, DONT_FREE_CACHE, 0, GINT_TO_POINTER(0)); setup_datapipe(&proximity_sensor_pipe, READ_ONLY, DONT_FREE_CACHE, 0, GINT_TO_POINTER(0)); setup_datapipe(&tk_lock_pipe, READ_ONLY, DONT_FREE_CACHE, 0, GINT_TO_POINTER(LOCK_UNDEF)); setup_datapipe(&charger_state_pipe, READ_ONLY, DONT_FREE_CACHE, 0, GINT_TO_POINTER(0)); setup_datapipe(&battery_status_pipe, READ_ONLY, DONT_FREE_CACHE, 0, GINT_TO_POINTER(BATTERY_STATUS_UNDEF)); setup_datapipe(&battery_level_pipe, READ_ONLY, DONT_FREE_CACHE, 0, GINT_TO_POINTER(100)); setup_datapipe(&camera_button_pipe, READ_ONLY, DONT_FREE_CACHE, 0, GINT_TO_POINTER(CAMERA_BUTTON_UNDEF)); setup_datapipe(&inactivity_timeout_pipe, READ_ONLY, DONT_FREE_CACHE, 0, GINT_TO_POINTER(DEFAULT_INACTIVITY_TIMEOUT)); setup_datapipe(&audio_route_pipe, READ_ONLY, DONT_FREE_CACHE, 0, GINT_TO_POINTER(AUDIO_ROUTE_UNDEF)); setup_datapipe(&usb_cable_pipe, READ_ONLY, DONT_FREE_CACHE, 0, GINT_TO_POINTER(0)); setup_datapipe(&jack_sense_pipe, READ_ONLY, DONT_FREE_CACHE, 0, GINT_TO_POINTER(0)); setup_datapipe(&power_saving_mode_pipe, READ_ONLY, DONT_FREE_CACHE, 0, GINT_TO_POINTER(0)); setup_datapipe(&thermal_state_pipe, READ_ONLY, DONT_FREE_CACHE, 0, GINT_TO_POINTER(THERMAL_STATE_UNDEF)); setup_datapipe(&heartbeat_pipe, READ_ONLY, DONT_FREE_CACHE, 0, GINT_TO_POINTER(0)); /* Initialise mode management * pre-requisite: mce_gconf_init() * pre-requisite: mce_dbus_init() */ if (mce_mode_init() == FALSE) { goto EXIT; } /* Initialise DSME * pre-requisite: mce_gconf_init() * pre-requisite: mce_dbus_init() * pre-requisite: mce_mce_init() */ if (mce_dsme_init(debugmode) == FALSE) { if (debugmode == FALSE) { mce_log(LL_CRIT, "Cannot connect to DSME"); goto EXIT; } } /* Initialise powerkey driver */ if (mce_powerkey_init() == FALSE) { goto EXIT; } /* Initialise /dev/input driver * pre-requisite: g_type_init() */ if (mce_input_init() == FALSE) { goto EXIT; } /* Initialise switch driver */ if (mce_switches_init() == FALSE) { goto EXIT; } /* Initialise tklock driver */ if (mce_tklock_init() == FALSE) { goto EXIT; } /* Load all modules */ if (mce_modules_init() == FALSE) { goto EXIT; } if (show_module_info == TRUE) { mce_modules_dump_info(); goto EXIT; } /* MCE startup succeeded */ status = EXIT_SUCCESS; /* Run the main loop */ g_main_loop_run(mainloop); /* If we get here, the main loop has terminated; * either because we requested or because of an error */ EXIT: /* Unload all modules */ mce_modules_exit(); /* Call the exit function for all components */ mce_tklock_exit(); mce_switches_exit(); mce_input_exit(); mce_powerkey_exit(); mce_dsme_exit(); mce_mode_exit(); /* Free all datapipes */ free_datapipe(&thermal_state_pipe); free_datapipe(&power_saving_mode_pipe); free_datapipe(&jack_sense_pipe); free_datapipe(&usb_cable_pipe); free_datapipe(&audio_route_pipe); free_datapipe(&inactivity_timeout_pipe); free_datapipe(&battery_level_pipe); free_datapipe(&battery_status_pipe); free_datapipe(&charger_state_pipe); free_datapipe(&tk_lock_pipe); free_datapipe(&proximity_sensor_pipe); free_datapipe(&lens_cover_pipe); free_datapipe(&lid_cover_pipe); free_datapipe(&keyboard_slide_pipe); free_datapipe(&lockkey_pipe); free_datapipe(&device_inactive_pipe); free_datapipe(&touchscreen_pipe); free_datapipe(&keypress_pipe); free_datapipe(&key_backlight_pipe); free_datapipe(&led_pattern_deactivate_pipe); free_datapipe(&led_pattern_activate_pipe); free_datapipe(&led_brightness_pipe); free_datapipe(&display_brightness_pipe); free_datapipe(&display_state_pipe); free_datapipe(&submode_pipe); free_datapipe(&alarm_ui_state_pipe); free_datapipe(&call_type_pipe); free_datapipe(&call_state_pipe); free_datapipe(&master_radio_pipe); free_datapipe(&system_state_pipe); free_datapipe(&heartbeat_pipe); /* Call the exit function for all subsystems */ mce_gconf_exit(); mce_dbus_exit(); mce_conf_exit(); /* If the mainloop is initialised, unreference it */ if (mainloop != NULL) { g_main_loop_unref(mainloop); mainloop = 0; } /* Log a farewell message and close the log */ mce_log(LL_INFO, "Exiting..."); /* We do not need to explicitly close the log and doing so * would not allow logging from atexit handlers */ //mce_log_close(); return status; }
int main(int argc, char **argv) { int e = 0; pid_t parent_pid = 0; stored_argc = argc; stored_argv = argv; /* * Settings in order of preference: * * 1: Settings specified in command line options... * 2: Settings specified in configuration file... * 3: Default settings * * Because of this, and because one option (-c) specifies where * the configuration file is, things are done in this order: * * 1. Read and set options. * 2. Read configuration file; if option is read in configuration * file and not already set, then set it. * 3. Having read configuration file, if parameter is not set, * set it to the default value. * * It is for this reason that the default values are **NOT** set * in the variable declaration... */ /* Report that server is starting (report will be delayed) */ report(RPT_NOTICE, "LCDd version %s starting", version); report(RPT_INFO, "Built on %s, protocol version %s, API version %s", build_date, protocol_version, api_version); clear_settings(); /* Read command line*/ CHAIN(e, process_command_line(argc, argv)); /* Read config file * If config file was not given on command line use default */ if (strcmp(configfile, UNSET_STR) == 0) strncpy(configfile, DEFAULT_CONFIGFILE, sizeof(configfile)); CHAIN(e, process_configfile(configfile)); /* Set default values*/ set_default_settings(); /* Set reporting settings (will also flush delayed reports) */ set_reporting("LCDd", report_level, report_dest); report(RPT_INFO, "Set report level to %d, output to %s", report_level, ((report_dest == RPT_DEST_SYSLOG) ? "syslog" : "stderr")); CHAIN_END(e, "Critical error while processing settings, abort."); /* Now, go into daemon mode (if we should)... * We wait for the child to report it is running OK. This mechanism * is used because forking after starting the drivers causes the * child to loose the (LPT) port access. */ if (!foreground_mode) { report(RPT_INFO, "Server forking to background"); CHAIN(e, parent_pid = daemonize()); } else { output_GPL_notice(); report(RPT_INFO, "Server running in foreground"); } install_signal_handlers(!foreground_mode); /* Only catch SIGHUP if not in foreground mode */ /* Startup the subparts of the server */ CHAIN(e, sock_init(bind_addr, bind_port)); CHAIN(e, screenlist_init()); CHAIN(e, init_drivers()); CHAIN(e, clients_init()); CHAIN(e, input_init()); CHAIN(e, menuscreens_init()); CHAIN(e, server_screen_init()); CHAIN_END(e, "Critical error while initializing, abort."); if (!foreground_mode) { /* Tell to parent that startup went OK. */ wave_to_parent(parent_pid); } drop_privs(user); /* This can't be done before, because sending a signal to a process of a different user will fail */ do_mainloop(); /* This loop never stops; we'll get out only with a signal...*/ return 0; }
mainwnd::mainwnd(perform *a_p): m_mainperf(a_p), m_modified(false), m_options(NULL) { set_icon(Gdk::Pixbuf::create_from_xpm_data(seq24_32_xpm)); /*sjh stuff...*/ set_wsetlist_mode(m_mainperf->get_setlist_mode()); /*............*/ /* register for notification */ m_mainperf->m_notify.push_back( this ); /* main window */ update_window_title(); #if GTK_MINOR_VERSION < 12 m_tooltips = manage( new Tooltips() ); #endif m_main_wid = manage( new mainwid( m_mainperf )); m_main_time = manage( new maintime( )); m_menubar = manage(new MenuBar()); m_menu_file = manage(new Menu()); m_menubar->items().push_front(MenuElem("_File", *m_menu_file)); m_menu_view = manage( new Menu()); m_menubar->items().push_back(MenuElem("_View", *m_menu_view)); m_menu_help = manage( new Menu()); m_menubar->items().push_back(MenuElem("_Help", *m_menu_help)); /* file menu items */ m_menu_file->items().push_back(MenuElem("_New", Gtk::AccelKey("<control>N"), mem_fun(*this, &mainwnd::file_new))); m_menu_file->items().push_back(MenuElem("_Open...", Gtk::AccelKey("<control>O"), mem_fun(*this, &mainwnd::file_open))); m_menu_file->items().push_back(MenuElem("_Save", Gtk::AccelKey("<control>S"), mem_fun(*this, &mainwnd::file_save))); m_menu_file->items().push_back(MenuElem("Save _as...", mem_fun(*this, &mainwnd::file_save_as))); m_menu_file->items().push_back(MenuElem("Open _setlist...", mem_fun(*this, &mainwnd::file_open_setlist))); m_menu_file->items().push_back(SeparatorElem()); m_menu_file->items().push_back(MenuElem("_Import...", mem_fun(*this, &mainwnd::file_import_dialog))); m_menu_file->items().push_back(MenuElem("O_ptions...", mem_fun(*this,&mainwnd::options_dialog))); m_menu_file->items().push_back(SeparatorElem()); m_menu_file->items().push_back(MenuElem("E_xit", Gtk::AccelKey("<control>Q"), mem_fun(*this, &mainwnd::file_exit))); /* view menu items */ m_menu_view->items().push_back(MenuElem("_Song Editor...", Gtk::AccelKey("<control>E"), mem_fun(*this, &mainwnd::open_performance_edit))); /* help menu items */ m_menu_help->items().push_back(MenuElem("_About...", mem_fun(*this, &mainwnd::about_dialog))); /* top line items */ HBox *tophbox = manage( new HBox( false, 0 ) ); tophbox->pack_start( *m_s24_pic, // *manage(new Image(Gdk::Pixbuf::create_from_xpm_data(seq24_xpm))), false, false); // adjust placement... VBox *vbox_b = manage( new VBox() ); HBox *hbox3 = manage( new HBox( false, 0 ) ); vbox_b->pack_start( *hbox3, false, false ); tophbox->pack_end( *vbox_b, false, false ); hbox3->set_spacing( 10 ); /* timeline */ hbox3->pack_start( *m_main_time, false, false ); /* group learn button */ m_button_learn = manage( new Button( )); m_button_learn->set_focus_on_click( false ); m_button_learn->set_flags( m_button_learn->get_flags() & ~Gtk::CAN_FOCUS ); m_button_learn->set_image(*manage(new Image( Gdk::Pixbuf::create_from_xpm_data( learn_xpm )))); m_button_learn->signal_clicked().connect( mem_fun(*this, &mainwnd::learn_toggle)); add_tooltip( m_button_learn, "Mute Group Learn\n\n" "Click 'L' then press a mutegroup key to store the mute state of " "the sequences in that key.\n\n" "(see File/Options/Keyboard for available mutegroup keys " "and the corresponding hotkey for the 'L' button)" ); hbox3->pack_end( *m_button_learn, false, false ); /*this seems to be a dirty hack:*/ Button w; hbox3->set_focus_child( w ); // clear the focus not to trigger L via keys /* bottom line items */ HBox *bottomhbox = manage( new HBox(false, 10)); /* container for start+stop buttons */ HBox *startstophbox = manage(new HBox(false, 4)); bottomhbox->pack_start(*startstophbox, Gtk::PACK_SHRINK); /* stop button */ m_button_stop = manage( new Button()); m_button_stop->add(*manage(new Image( Gdk::Pixbuf::create_from_xpm_data( stop_xpm )))); m_button_stop->signal_clicked().connect( mem_fun(*this, &mainwnd::stop_playing));/*sjh - can't pass anything into the stop_playing function because of this. */ add_tooltip( m_button_stop, "Stop playing MIDI sequence" ); m_button_stop->set_can_focus(false); startstophbox->pack_start(*m_button_stop, Gtk::PACK_SHRINK); /* play button */ m_button_play = manage(new Button() ); m_button_play->add(*manage(new Image( Gdk::Pixbuf::create_from_xpm_data( play2_xpm )))); m_button_play->signal_clicked().connect( mem_fun( *this, &mainwnd::start_playing)); add_tooltip( m_button_play, "Play MIDI sequence" ); startstophbox->pack_start(*m_button_play, Gtk::PACK_SHRINK); /* bpm spin button with label*/ HBox *bpmhbox = manage(new HBox(false, 4)); bottomhbox->pack_start(*bpmhbox, Gtk::PACK_SHRINK); m_adjust_bpm = manage(new Adjustment(m_mainperf->get_bpm(), 20, 500, 1)); m_spinbutton_bpm = manage( new SpinButton( *m_adjust_bpm )); m_spinbutton_bpm->set_editable( false ); m_adjust_bpm->signal_value_changed().connect( mem_fun(*this, &mainwnd::adj_callback_bpm)); add_tooltip( m_spinbutton_bpm, "Adjust beats per minute (BPM) value"); Label* bpmlabel = manage(new Label("_bpm", true)); bpmlabel->set_mnemonic_widget(*m_spinbutton_bpm); bpmhbox->pack_start(*bpmlabel, Gtk::PACK_SHRINK); bpmhbox->pack_start(*m_spinbutton_bpm, Gtk::PACK_SHRINK); /* screen set name edit line */ HBox *notebox = manage(new HBox(false, 4)); bottomhbox->pack_start(*notebox, Gtk::PACK_EXPAND_WIDGET); m_entry_notes = manage( new Entry()); m_entry_notes->signal_changed().connect( mem_fun(*this, &mainwnd::edit_callback_notepad)); m_entry_notes->set_text(*m_mainperf->get_screen_set_notepad( m_mainperf->get_screenset())); add_tooltip( m_entry_notes, "Enter screen set name" ); Label* notelabel = manage(new Label("_Name", true)); notelabel->set_mnemonic_widget(*m_entry_notes); notebox->pack_start(*notelabel, Gtk::PACK_SHRINK); notebox->pack_start(*m_entry_notes, Gtk::PACK_EXPAND_WIDGET); /* sequence set spin button */ HBox *sethbox = manage(new HBox(false, 4)); bottomhbox->pack_start(*sethbox, Gtk::PACK_SHRINK); m_adjust_ss = manage( new Adjustment( 0, 0, c_max_sets - 1, 1 )); m_spinbutton_ss = manage( new SpinButton( *m_adjust_ss )); m_spinbutton_ss->set_editable( false ); m_spinbutton_ss->set_wrap( true ); m_adjust_ss->signal_value_changed().connect( mem_fun(*this, &mainwnd::adj_callback_ss )); add_tooltip( m_spinbutton_ss, "Select screen set" ); Label* setlabel = manage(new Label("_Set", true)); setlabel->set_mnemonic_widget(*m_spinbutton_ss); sethbox->pack_start(*setlabel, Gtk::PACK_SHRINK); sethbox->pack_start(*m_spinbutton_ss, Gtk::PACK_SHRINK); /* song edit button */ m_button_songedit = manage( new Button( )); m_button_songedit->add( *manage( new Image( Gdk::Pixbuf::create_from_xpm_data( perfedit_xpm )))); m_button_songedit->signal_clicked().connect( mem_fun( *this, &mainwnd::open_performance_edit )); add_tooltip( m_button_songedit, "Show or hide song editor window" ); bottomhbox->pack_end(*m_button_songedit, Gtk::PACK_SHRINK); /* vertical layout container for window content*/ VBox *contentvbox = new VBox(); contentvbox->set_spacing(10); contentvbox->set_border_width(10); contentvbox->pack_start(*tophbox, Gtk::PACK_SHRINK); contentvbox->pack_start(*m_main_wid, Gtk::PACK_SHRINK); contentvbox->pack_start(*bottomhbox, Gtk::PACK_SHRINK); /*main container for menu and window content */ VBox *mainvbox = new VBox(); mainvbox->pack_start(*m_menubar, false, false ); mainvbox->pack_start( *contentvbox ); /* add main layout box */ this->add (*mainvbox); /* show everything */ show_all(); add_events( Gdk::KEY_PRESS_MASK | Gdk::KEY_RELEASE_MASK ); m_timeout_connect = Glib::signal_timeout().connect( mem_fun(*this, &mainwnd::timer_callback), 25); m_perf_edit = new perfedit( m_mainperf ); // m_playlist_wnd = new playlist_wnd( m_mainperf); m_playplay = new playlist_player(); m_sigpipe[0] = -1; m_sigpipe[1] = -1; install_signal_handlers(); }
int main(int argc, char **argv) { srvr_sockaddr_union_t me; struct tftphdr *tp; ssize_t n = 0; int arg = 1; unsigned short port = DEFAULT_PORT; curl_socket_t sock = CURL_SOCKET_BAD; int flag; int rc; int error; long pid; struct testcase test; int result = 0; memset(&test, 0, sizeof(test)); while(argc>arg) { if(!strcmp("--version", argv[arg])) { printf("tftpd IPv4%s\n", #ifdef ENABLE_IPV6 "/IPv6" #else "" #endif ); return 0; } else if(!strcmp("--pidfile", argv[arg])) { arg++; if(argc>arg) pidname = argv[arg++]; } else if(!strcmp("--logfile", argv[arg])) { arg++; if(argc>arg) serverlogfile = argv[arg++]; } else if(!strcmp("--ipv4", argv[arg])) { #ifdef ENABLE_IPV6 ipv_inuse = "IPv4"; use_ipv6 = FALSE; #endif arg++; } else if(!strcmp("--ipv6", argv[arg])) { #ifdef ENABLE_IPV6 ipv_inuse = "IPv6"; use_ipv6 = TRUE; #endif arg++; } else if(!strcmp("--port", argv[arg])) { arg++; if(argc>arg) { char *endptr; unsigned long ulnum = strtoul(argv[arg], &endptr, 10); if((endptr != argv[arg] + strlen(argv[arg])) || (ulnum < 1025UL) || (ulnum > 65535UL)) { fprintf(stderr, "tftpd: invalid --port argument (%s)\n", argv[arg]); return 0; } port = curlx_ultous(ulnum); arg++; } } else if(!strcmp("--srcdir", argv[arg])) { arg++; if(argc>arg) { path = argv[arg]; arg++; } } else { puts("Usage: tftpd [option]\n" " --version\n" " --logfile [file]\n" " --pidfile [file]\n" " --ipv4\n" " --ipv6\n" " --port [port]\n" " --srcdir [path]"); return 0; } } #ifdef WIN32 win32_init(); atexit(win32_cleanup); #endif install_signal_handlers(); pid = (long)getpid(); #ifdef ENABLE_IPV6 if(!use_ipv6) #endif sock = socket(AF_INET, SOCK_DGRAM, 0); #ifdef ENABLE_IPV6 else sock = socket(AF_INET6, SOCK_DGRAM, 0); #endif if(CURL_SOCKET_BAD == sock) { error = SOCKERRNO; logmsg("Error creating socket: (%d) %s", error, strerror(error)); result = 1; goto tftpd_cleanup; } flag = 1; if (0 != setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *)&flag, sizeof(flag))) { error = SOCKERRNO; logmsg("setsockopt(SO_REUSEADDR) failed with error: (%d) %s", error, strerror(error)); result = 1; goto tftpd_cleanup; } #ifdef ENABLE_IPV6 if(!use_ipv6) { #endif memset(&me.sa4, 0, sizeof(me.sa4)); me.sa4.sin_family = AF_INET; me.sa4.sin_addr.s_addr = INADDR_ANY; me.sa4.sin_port = htons(port); rc = bind(sock, &me.sa, sizeof(me.sa4)); #ifdef ENABLE_IPV6 } else { memset(&me.sa6, 0, sizeof(me.sa6)); me.sa6.sin6_family = AF_INET6; me.sa6.sin6_addr = in6addr_any; me.sa6.sin6_port = htons(port); rc = bind(sock, &me.sa, sizeof(me.sa6)); } #endif /* ENABLE_IPV6 */ if(0 != rc) { error = SOCKERRNO; logmsg("Error binding socket on port %hu: (%d) %s", port, error, strerror(error)); result = 1; goto tftpd_cleanup; } wrotepidfile = write_pidfile(pidname); if(!wrotepidfile) { result = 1; goto tftpd_cleanup; } logmsg("Running %s version on port UDP/%d", ipv_inuse, (int)port); for (;;) { fromlen = sizeof(from); #ifdef ENABLE_IPV6 if(!use_ipv6) #endif fromlen = sizeof(from.sa4); #ifdef ENABLE_IPV6 else fromlen = sizeof(from.sa6); #endif n = (ssize_t)recvfrom(sock, &buf.storage[0], sizeof(buf.storage), 0, &from.sa, &fromlen); if(got_exit_signal) break; if (n < 0) { logmsg("recvfrom"); result = 3; break; } set_advisor_read_lock(SERVERLOGS_LOCK); serverlogslocked = 1; #ifdef ENABLE_IPV6 if(!use_ipv6) { #endif from.sa4.sin_family = AF_INET; peer = socket(AF_INET, SOCK_DGRAM, 0); if(CURL_SOCKET_BAD == peer) { logmsg("socket"); result = 2; break; } if(connect(peer, &from.sa, sizeof(from.sa4)) < 0) { logmsg("connect: fail"); result = 1; break; } #ifdef ENABLE_IPV6 } else { from.sa6.sin6_family = AF_INET6; peer = socket(AF_INET6, SOCK_DGRAM, 0); if(CURL_SOCKET_BAD == peer) { logmsg("socket"); result = 2; break; } if (connect(peer, &from.sa, sizeof(from.sa6)) < 0) { logmsg("connect: fail"); result = 1; break; } } #endif maxtimeout = 5*TIMEOUT; tp = &buf.hdr; tp->th_opcode = ntohs(tp->th_opcode); if (tp->th_opcode == opcode_RRQ || tp->th_opcode == opcode_WRQ) { memset(&test, 0, sizeof(test)); if (do_tftp(&test, tp, n) < 0) break; if(test.buffer) free(test.buffer); } sclose(peer); peer = CURL_SOCKET_BAD; if(test.ofile > 0) { close(test.ofile); test.ofile = 0; } if(got_exit_signal) break; if(serverlogslocked) { serverlogslocked = 0; clear_advisor_read_lock(SERVERLOGS_LOCK); } logmsg("end of one transfer"); } tftpd_cleanup: if(test.ofile > 0) close(test.ofile); if((peer != sock) && (peer != CURL_SOCKET_BAD)) sclose(peer); if(sock != CURL_SOCKET_BAD) sclose(sock); if(got_exit_signal) logmsg("signalled to die"); if(wrotepidfile) unlink(pidname); if(serverlogslocked) { serverlogslocked = 0; clear_advisor_read_lock(SERVERLOGS_LOCK); } restore_signal_handlers(); if(got_exit_signal) { logmsg("========> %s tftpd (port: %d pid: %ld) exits with signal (%d)", ipv_inuse, (int)port, pid, exit_signal); /* * To properly set the return status of the process we * must raise the same signal SIGINT or SIGTERM that we * caught and let the old handler take care of it. */ raise(exit_signal); } logmsg("========> tftpd quits"); return result; }