int daemon_main()
{
network_init(); // (WSAStartup())
register_signals();
sdns::conf.read_config();
try {
tcp_thread tcp;
eventloop eloop(&tcp);
tcp.set_pointers(&eloop);
if(sdns::conf[sdns::SDNS_USER] != "")
drop_root(sdns::conf[sdns::SDNS_USER]);
else
dout() << "SDNS_USER not set, not changing uid/gid";
std::thread eventloop_th(std::ref(eloop));
std::thread tcp_th(std::ref(tcp));
while(true) {
os_event event = wait_for_os_event();
if(event == os_event::shutdown) break;
if(event == os_event::reload) eloop.reread_static_records();
}
eloop.stop();
tcp.stop();
eventloop_th.join();
tcp_th.join();
} catch(const e_exception &e) {
eout() << "Error at main(): " << e;
eout() << "errno was: " << errno << ": " << strerror_rp(errno);
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
Tree_active& Tree_active::operator=(Tree_active&& t)
{
Tree::operator=(std::move(t));
register_signals();
return *this;
}
Tree_active& Tree_active::operator=(const Tree_active& t)
{
Tree::operator=(t);
register_signals();
return *this;
}
int main(int argc, char **argv) {
int opt;
int daemon = 0;
int port = SERVER_PORT;
int server_fd;
pid_t pid, sid;
/* Launch options */
while ((opt = getopt(argc, argv, "dvp:")) != -1) {
switch (opt) {
case 'd':
daemon = 1;
break;
case 'v':
debug = 1;
break;
case 'p':
port = atoi(optarg);
break;
default:
printf("Usage: %s [-d] [-v] [-p port]\n", argv[0]);
exit(EXIT_FAILURE);
break;
}
}
/* Signal handling */
register_signals();
deprintf ("Starting at port %d\n", port);
/* Daemonify */
if (daemon) {
deprintf ("Starting as daemon\n");
pid = fork();
if (pid < 0) {
exit(EXIT_FAILURE);
} else if (pid > 0) {
exit(EXIT_SUCCESS);
}
umask(0);
sid = setsid();
if (sid < 0) {
exit(EXIT_FAILURE);
}
}
/* INIT client nodes */
TAILQ_INIT(&client_nodes);
server_fd = server_init(port);
server_shutdown(server_fd);
printf("Shutting down server.\n");
return 0;
}
int main(int argc, char *argv[])
{
char *dir;
struct dirent **nl;
long int rnd;
int n, i;
if (register_signals() < 0){
fprintf(stderr, "e: signals\n");
return EX_USAGE;
}
if(argc == 2)
dir = argv[1];
else
return 0;
srand(time(NULL));
n = scandir(dir, &nl, 0, alphasort);
if (n < 0){
fprintf(stderr, "e: %s\n", strerror(errno));
//goto fnl;
return 1;
}
struct priority_queue *pq;
struct dirent *data;
pq = create_priority_queue();
for (i=0; i<n; i++){
rnd = rand() % n;
insert_with_priority_queue(pq, rnd, nl[i]);
}
for (i=0; i<n; i++){
if (pull_highest_priority(pq, (void **) &data) == 0){
if (data->d_name[0] != '.')
fprintf(stdout, "%s\n", data->d_name);
}
}
while(n--){
if (nl[n])
free(nl[n]);
}
if (nl)
free(nl);
destroy_priority_queue(pq, NULL);
destroy_shared_mem();
return 0;
}
Tree_active::Tree_active(Dir_preview* dp, Gtk::Box& box)
: Tree{dp, box}
{
box.pack_start(get_widget(), Gtk::PACK_EXPAND_WIDGET);
m_tree_view->set_sensitive();
m_tree_view->grab_focus();
m_separator->set_margin_left(2);
m_separator->set_margin_right(2);
box.pack_start(*m_separator, Gtk::PACK_SHRINK);
// register the signals
// Note that we're registering on_cursor_change signal AFTER setting the
// cursor on purpose - we don't need to check the cursor for preview as
// this was already done by libhawk when we created this tab.
register_signals();
}
int
main (int argc, char *argv[])
{
char *l = NULL;
message_t *cmsg = NULL;
command_t *ccmd = NULL;
settings_t global_settings;
settings = &global_settings;
settings->execname = argv[0];
settings->action_trigger = '`'; /* default trigger char */
settings->verbose = false;
settings->socket = NULL;
logstr ("Radroach here\n");
register_signals ();
if (configure (argc, argv))
exit (EXIT_FAILURE);
logstr ("trusted users are: %s\n", settings->trusted);
if (settings->aj_list)
logstr ("channels to join: %s\n", settings->aj_list);
server_connect (settings->host);
setup ();
plugins_load ("./plugins/");
while ((l = sogetline ()) != NULL)
{
if (p_response (l))
continue;
cmsg = parsemsg (l);
if (cmsg != NULL)
{
ccmd = parsecmd (cmsg->msg);
if (ccmd != NULL)
execute (cmsg, ccmd);
}
else
free (l);
}
return EXIT_SUCCESS;
}
Tree_active::Tree_active(Tree_active&& t)
: Tree{std::move(t)}
{
register_signals();
}
Tree_active::Tree_active(const Tree_active& t)
: Tree{t}
{
register_signals();
}
/*
* Main program
*/
int
main(int argc, char *argv[])
{
char *p;
char errormsg[256];
static char environment_name[] = "SESSION_MANAGER";
int success, found_command_line_name, i;
Argc = argc;
Argv = argv;
for (i = 1; i < argc; i++)
{
if (argv[i][0] == '-')
{
switch (argv[i][1])
{
case 'd': /* -display */
if (++i >= argc) goto usage;
cmd_line_display = (char *) XtNewString (argv[i]);
continue;
case 's': /* -session */
if (++i >= argc) goto usage;
session_name = XtNewString (argv[i]);
continue;
case 'v': /* -verbose */
verbose = 1;
continue;
}
}
usage:
fprintf (stderr,
"usage: xsm [-display display] [-session session_name] [-verbose]\n");
exit (1);
}
topLevel = XtVaAppInitialize (&appContext, "XSm", NULL, 0,
&argc, argv, NULL,
XtNmappedWhenManaged, False,
XtNwindowRole, "xsm main window",
NULL);
wmStateAtom = XInternAtom (
XtDisplay (topLevel), "WM_STATE", False);
wmDeleteAtom = XInternAtom (
XtDisplay (topLevel), "WM_DELETE_WINDOW", False);
register_signals (appContext);
/*
* Install an IO error handler. For an explanation,
* see the comments for InstallIOErrorHandler().
*/
InstallIOErrorHandler ();
/*
* Init SM lib
*/
if (!SmsInitialize ("SAMPLE-SM", "1.0",
NewClientProc, NULL,
HostBasedAuthProc, 256, errormsg))
{
fprintf (stderr, "%s\n", errormsg);
exit (1);
}
if (!IceListenForConnections (&numTransports, &listenObjs,
256, errormsg))
{
fprintf (stderr, "%s\n", errormsg);
exit (1);
}
atexit(CloseListeners);
if (!SetAuthentication (numTransports, listenObjs, &authDataEntries))
{
fprintf (stderr, "Could not set authorization\n");
exit (1);
}
InitWatchProcs (appContext);
for (i = 0; i < numTransports; i++)
{
XtAppAddInput (appContext,
IceGetListenConnectionNumber (listenObjs[i]),
(XtPointer) XtInputReadMask,
NewConnectionXtProc, (XtPointer) listenObjs[i]);
}
/* the sizeof includes the \0, so we don't need to count the '=' */
networkIds = IceComposeNetworkIdList (numTransports, listenObjs);
p = (char *) XtMalloc((sizeof environment_name) + strlen(networkIds) + 1);
if(!p) nomem();
sprintf(p, "%s=%s", environment_name, networkIds);
putenv(p);
if (cmd_line_display)
{
/*
* If a display was passed on the command line, set the DISPLAY
* environment in this process so all applications started by
* the session manager will run on the specified display.
*/
p = (char *) XtMalloc(8 + strlen(cmd_line_display) + 1);
sprintf(p, "DISPLAY=%s", cmd_line_display);
putenv(p);
}
if (verbose)
printf ("setenv %s %s\n", environment_name, networkIds);
create_choose_session_popup ();
create_main_window ();
create_client_info_popup ();
create_save_popup ();
create_log_popup ();
/*
* Initalize all lists
*/
RunningList = ListInit();
if(!RunningList) nomem();
PendingList = ListInit();
if(!PendingList) nomem();
RestartAnywayList = ListInit();
if(!RestartAnywayList) nomem();
RestartImmedList = ListInit();
if(!RestartImmedList) nomem();
WaitForSaveDoneList = ListInit();
if (!WaitForSaveDoneList) nomem();
InitialSaveList = ListInit();
if (!InitialSaveList) nomem();
FailedSaveList = ListInit();
if (!FailedSaveList) nomem();
WaitForInteractList = ListInit();
if (!WaitForInteractList) nomem();
WaitForPhase2List = ListInit();
if (!WaitForPhase2List) nomem();
/*
* Get list of session names. If a session name was found on the
* command line, and it is in the list of session names we got, then
* use that session name. If there were no session names found, then
* use the default session name. Otherwise, present a list of session
* names for the user to choose from.
*/
success = GetSessionNames (&sessionNameCount,
&sessionNamesShort, &sessionNamesLong, &sessionsLocked);
found_command_line_name = 0;
if (success && session_name)
{
for (i = 0; i < sessionNameCount; i++)
if (strcmp (session_name, sessionNamesShort[i]) == 0)
{
found_command_line_name = 1;
if (sessionsLocked[i])
{
fprintf (stderr, "Session '%s' is locked\n", session_name);
exit (1);
}
break;
}
}
if (!success || found_command_line_name)
{
FreeSessionNames (sessionNameCount,
sessionNamesShort, sessionNamesLong, sessionsLocked);
if (!found_command_line_name)
session_name = XtNewString (DEFAULT_SESSION_NAME);
if (!StartSession (session_name, !found_command_line_name))
UnableToLockSession (session_name);
}
else
{
ChooseSession ();
}
/*
* Main loop
*/
XtAppMainLoop (appContext);
exit(0);
}
int
auth_initialize(char *authfilename)
{
int n;
AuthList *head, *tail;
FILE *authfp;
Bool exists;
xauth_filename = authfilename; /* used in cleanup, prevent race with
signals */
register_signals ();
bzero ((char *) hexvalues, sizeof hexvalues);
hexvalues['0'] = 0;
hexvalues['1'] = 1;
hexvalues['2'] = 2;
hexvalues['3'] = 3;
hexvalues['4'] = 4;
hexvalues['5'] = 5;
hexvalues['6'] = 6;
hexvalues['7'] = 7;
hexvalues['8'] = 8;
hexvalues['9'] = 9;
hexvalues['a'] = hexvalues['A'] = 0xa;
hexvalues['b'] = hexvalues['B'] = 0xb;
hexvalues['c'] = hexvalues['C'] = 0xc;
hexvalues['d'] = hexvalues['D'] = 0xd;
hexvalues['e'] = hexvalues['E'] = 0xe;
hexvalues['f'] = hexvalues['F'] = 0xf;
if (break_locks && verbose) {
printf ("Attempting to break locks on authority file %s\n",
authfilename);
}
if (ignore_locks) {
if (break_locks) XauUnlockAuth (authfilename);
} else {
n = XauLockAuth (authfilename, XAUTH_DEFAULT_RETRIES,
XAUTH_DEFAULT_TIMEOUT,
(break_locks ? 0L : XAUTH_DEFAULT_DEADTIME));
if (n != LOCK_SUCCESS) {
char *reason = "unknown error";
switch (n) {
case LOCK_ERROR:
reason = "error";
break;
case LOCK_TIMEOUT:
reason = "timeout";
break;
}
fprintf (stderr, "%s: %s in locking authority file %s\n",
ProgramName, reason, authfilename);
return -1;
} else
xauth_locked = True;
}
/* these checks can only be done reliably after the file is locked */
exists = (access (authfilename, F_OK) == 0);
if (exists && access (authfilename, W_OK) != 0) {
fprintf (stderr,
"%s: %s not writable, changes will be ignored\n",
ProgramName, authfilename);
xauth_allowed = False;
}
original_umask = umask (0077); /* disallow non-owner access */
authfp = fopen (authfilename, "rb");
if (!authfp) {
int olderrno = errno;
/* if file there then error */
if (access (authfilename, F_OK) == 0) { /* then file does exist! */
errno = olderrno;
return -1;
} /* else ignore it */
fprintf (stderr,
"%s: creating new authority file %s\n",
ProgramName, authfilename);
} else {
xauth_existed = True;
n = read_auth_entries (authfp, False, &head, &tail);
(void) fclose (authfp);
if (n < 0) {
fprintf (stderr,
"%s: unable to read auth entries from file \"%s\"\n",
ProgramName, authfilename);
return -1;
}
xauth_head = head;
}
n = strlen (authfilename);
xauth_filename = malloc (n + 1);
if (xauth_filename) strcpy (xauth_filename, authfilename);
else {
fprintf(stderr,"cannot allocate memory\n");
return -1;
}
xauth_modified = False;
if (verbose) {
printf ("%s authority file %s\n",
ignore_locks ? "Ignoring locks on" : "Using", authfilename);
}
return 0;
}
int init_c_lib(int argc, const char* argv[])
{
static int inited = 0;
GS_ASSERT_ABORT(!(inited++));
register_signals();
create_path(SCREENSHOT_PATH);
create_path(DATA_PATH);
Log::init();
Options::init_option_tables();
LUA::init_options();
Options::register_options();
LUA::load_options(); //load game options
Options::parse_args(argc, argv);
Options::validate();
printf("Server init\n");
srand((unsigned int)time(NULL));
printf("Auth ");
if (Options::auth)
printf("enabled\n");
else
printf("disabled\n");
printf("Serializer ");
if (Options::serializer)
printf("enabled\n");
else
printf("disabled\n");
printf("PVP ");
if (Options::pvp)
printf("enabled\n");
else
printf("disabled\n");
Attributes::init();
Agents::init_attributes();
World::init_attributes();
t_mob::init();
Badges::init();
Components::init();
Entities::init_net_interfaces();
VoxDats::init();
Chat::init_chat_server();
NetServer::init_globals();
init_network();
Auth::init();
Sound::init();
Animations::init();
t_map::init_t_map();
init_configs();
Item::init();
ItemContainer::init();
Toolbelt::init();
t_mech::init();
t_plant::init();
Agents::init();
ServerState::init_lists();
Particle::init_particles();
ItemParticle::init();
serializer::init();
t_gen::init();
t_gen::init_map_generator();
Path::init();
return 0;
}
int main(int argc, char *argv[])
{
char option[2];
int n;
int err=0;
if(!argc) usage(argv[0]);
clone_args( argv, argc );
#if !GLIB_CHECK_VERSION(2,36,0)
g_type_init();
#endif
gtk_init( &argc, &argv );
// default host to connect to
snprintf(hostname,sizeof(hostname), "127.0.0.1");
while( ( n = getopt( argc, argv, "s:h:p:tabnvLHfX:P:Vl:T:m:g:")) != EOF )
{
sprintf(option, "%c", n );
err += set_option( option, optarg);
if(err) usage(argv[0]);
}
if( optind > argc )
err ++;
if( err ) usage(argv[0]);
glade_init();
vj_mem_init();
vevo_strict_init();
find_user_themes(gveejay_theme);
vj_gui_set_debug_level( verbosity , n_tracks,0,0);
set_skin( selected_skin, gveejay_theme );
default_bank_values( &col, &row );
gui_load_theme();
register_signals();
vj_gui_init( skins[selected_skin].file, launcher, hostname, port_num, use_threads, load_midi, midi_file,beta,auto_connect);
vj_gui_style_setup();
if( preview )
{
veejay_msg(VEEJAY_MSG_INFO, "Starting with preview enabled");
gveejay_preview(preview);
}
if( launcher )
{
reloaded_launcher( hostname, port_num );
}
memset( &time_last_, 0, sizeof(struct timeval));
while(gveejay_running())
{
if(gveejay_idle(NULL)==FALSE)
break;
while( gtk_events_pending() )
gtk_main_iteration();
}
veejay_msg(VEEJAY_MSG_INFO, "See you!");
return 0;
}
int main(int argc, char * argv[])
{
struct spead_socket *x;
struct spead_client *c;
sslKeys_t *keys;
int32 err;
if (register_signals() < 0)
return 1;
x = create_tcp_socket(NULL, "3333");
if (x == NULL)
return 1;
if (bind_spead_socket(x) < 0){
destroy_spead_socket(x);
destroy_shared_mem();
return 1;
}
if (listen_spead_socket(x) < 0) {
destroy_spead_socket(x);
destroy_shared_mem();
return 1;
}
err = matrixSslOpen();
if (err != PS_SUCCESS){
#ifdef DEBUG
fprintf(stderr, "%s: error setting up matrixssl\n", __func__);
#endif
destroy_spead_socket(x);
destroy_shared_mem();
return 1;
}
err = matrixSslNewKeys(&keys);
if (err != PS_SUCCESS){
#ifdef DEBUG
fprintf(stderr, "%s: error allocationg matrixssl keys\n", __func__);
#endif
destroy_spead_socket(x);
destroy_shared_mem();
matrixSslClose();
return 1;
}
err = matrixSslLoadRsaKeys(keys, "./certs/server.crt", "./certs/server.key", NULL, NULL);
if (err != PS_SUCCESS){
#ifdef DEBUG
switch(err){
case PS_CERT_AUTH_FAIL:
fprintf(stderr, "Certificate or chain did not self-authenticate or private key could not authenticate certificate\n");
break;
case PS_PLATFORM_FAIL:
fprintf(stderr, "Error locating or opening an input file\n");
break;
case PS_ARG_FAIL:
fprintf(stderr, "Bad input function parameter\n");
break;
case PS_MEM_FAIL:
fprintf(stderr, "Internal memory allocation failure\n");
break;
case PS_PARSE_FAIL:
fprintf(stderr, "Error parsing certificate or private key buffer\n");
break;
case PS_FAILURE:
fprintf(stderr, "Password protected decoding failed. Likey incorrect password provided\n");
break;
case PS_UNSUPPORTED_FAIL:
fprintf(stderr, "Unsupported key algorithm in certificate material\n");
break;
}
#endif
destroy_spead_socket(x);
destroy_shared_mem();
matrixSslDeleteKeys(keys);
matrixSslClose();
return 1;
}
while (run){
c = accept_spead_socket(x);
if (c){
switch(fork()){
case -1:
#ifdef DEBUG
fprintf(stderr, "%s: fork err (%s)\n", __func__, strerror(errno));
#endif
break;
/*child*/
case 0:
/*child process takes over the accept object*/
child_process(c, keys);
exit(EXIT_SUCCESS);
break;
/*parent*/
default:
#ifdef DEBUG
fprintf(stderr, "%s: close the child fd on the parent\n", __func__);
#endif
/*server closes the file descriptor and frees the object but doesn't
shutdown the connection from accept*/
close(c->c_fd);
free(c);
break;
}
}
}
destroy_spead_socket(x);
destroy_shared_mem();
matrixSslDeleteKeys(keys);
matrixSslClose();
return 0;
}
/* main - Start of shell, doesn't care for arguments */
int main(int argc, char* argv[])
{
int retval;
char cmd_line[MAX_LENGTH];
/* Allocate memory for argument vector */
char **args = (char **) malloc(MAX_ARGS * sizeof(char*));
/* Register proper signals to handle */
register_signals();
/* Set string for promt */
USER = getenv("USER");
/* Main loop */
while (1)
{
#ifndef SIGNALDETECTION
/* Check if any background processes has exited */
retval = check_background_procs();
if (retval == -1 && errno != ECHILD)
perror("wait failed");
#endif
/* Print a new promt */
print_prompt();
/* Fetch new command from terminal */
if (fgets(cmd_line, MAX_LENGTH, stdin) != NULL) /* Success */
{
/* Parse user command */
retval = parse_command(cmd_line, args);
if (retval == 1) /* Empty cmd */
continue; /* Restart loop, for checking background etc.. */
/* If the command is available as a builtin, use that */
if (builtin(args))
{
retval = run_builtin(args);
if (retval == B_EXIT) /* EXIT */
{
retval = check_background_procs();
/* retval == 0 means no error for having no children were
* returned */
/* Kill all child processes */
if (retval == 0)
retval = kill(-getpid(), SIGKILL);
break; /* Breaks main loop and exits */
}
else if (retval == B_FALIURE) /* Something went wrong */
fprintf(stderr, "Command, %s, could not be executed\n", args[0]);
}
else /* Run a command */
{
/* Run in the background */
if (background(args))
{
run_program(args, 1);
}
else /* Run blocking */
{
retval = run_program_block(args);
if (retval IS_ERROR)
{
if (retval == INVALIDARGS)
fprintf(stderr, "Invalid argument\n");
else if (retval == PIPEERROR)
fprintf(stderr, "Pipe error\n");
else if (retval == FORKERROR)
fprintf(stderr, "Fork error\n");
}
}
}
}
}
/* Free memmory */
free(args);
return 0;
}
int main(int argc, char** argv)
{
const char *pid_str;
char str[ 16 ];
GKeyFile* kf;
pid_str = g_getenv(pid_env);
display_name = g_getenv( display_env );
if( ! display_name )
{
display_name = ":0.0";
g_setenv( display_env, display_name, TRUE );
}
parse_options(argc, argv);
/* initialize X-related stuff and connect to X Display */
if( G_UNLIKELY(! xevent_init() ) )
return 1;
/* send command to existing daemon to reload settings */
if( G_UNLIKELY( reload_settings ) )
{
send_internal_command( LXS_RELOAD );
return 0;
}
else if( G_UNLIKELY( !single_instance_check()) )
{
/* only one instance is allowed for each X. */
fprintf(stderr, "Only one lxsession can be executed at a time");
return 1;
}
/* set pid */
g_snprintf( str, 16, "%d", getpid() );
g_setenv(pid_env, str, TRUE );
main_loop = g_main_loop_new( NULL, TRUE );
/* setup signal handlers */
register_signals();
if ( G_UNLIKELY(!session_name) )
session_name = "LXDE";
g_setenv( "DESKTOP_SESSION", session_name, TRUE );
if ( G_UNLIKELY(!de_name) )
de_name = session_name;
g_setenv( "XDG_CURRENT_DESKTOP", de_name, TRUE );
/* FIXME: load environment variables? */
/* Load desktop session config file */
kf = load_session_config(CONFIG_FILE_NAME);
if( !kf )
{
xevent_finalize();
return 1;
}
window_manager = g_key_file_get_string( kf, "Session", "window_manager", NULL );
if( G_LIKELY(!no_settings) )
start_settings_daemon(kf);
g_key_file_free(kf);
/* start desktop session and load autostart applications */
start_session();
g_main_loop_run( main_loop );
g_main_loop_unref( main_loop );
xevent_finalize();
return 0;
}
