Example #1
0
static void
test_write_fail(void)
{
  int status;
  pid_t pid;
  ThriftSocket *tsocket = NULL;
  ThriftTransport *transport = NULL;
  int port = 51198;
  guchar buf[10] = TEST_DATA; /* a buffer */

  /* SIGPIPE when send to disconnected socket */
  signal(SIGPIPE, SIG_IGN);

  pid = fork ();
  assert ( pid >= 0 );

  if ( pid == 0 )
  {
    /* child listens */
    ThriftServerTransport *transport = NULL;
    ThriftTransport *client = NULL;

    ThriftServerSocket *tsocket = g_object_new (THRIFT_TYPE_SERVER_SOCKET,
        "port", port, NULL);

    transport = THRIFT_SERVER_TRANSPORT (tsocket);
    thrift_server_transport_listen (transport, NULL);

    /* wrap the client in a BufferedTransport */
    client = g_object_new (THRIFT_TYPE_BUFFERED_TRANSPORT, "transport",
        thrift_server_transport_accept (transport, NULL),
        "r_buf_size", 5, NULL);
    assert (client != NULL);

    /* just close socket */
    thrift_buffered_transport_close (client, NULL);
    g_object_unref (client);
    g_object_unref (tsocket);
    exit (0);
  } else {
    /* parent connects, wait a bit for the socket to be created */
    sleep (1);

    tsocket = g_object_new (THRIFT_TYPE_SOCKET, "hostname", "localhost",
                            "port", port, NULL);
    transport = g_object_new (THRIFT_TYPE_BUFFERED_TRANSPORT,
                              "transport", THRIFT_TRANSPORT (tsocket),
                              "w_buf_size", 4, NULL);


    assert (thrift_buffered_transport_open (transport, NULL) == TRUE);
    assert (thrift_buffered_transport_is_open (transport));

    /* recognize disconnection */
    sleep(1);
    assert (thrift_buffered_transport_write (transport, buf, 10, NULL) == TRUE);
    assert (thrift_buffered_transport_write (transport, buf, 10, NULL) == FALSE);

    /* write and overflow buffer */
    assert (thrift_buffered_transport_write (transport, buf, 10, NULL) == FALSE);

    /* write 1 and flush */
    assert (thrift_buffered_transport_write (transport, buf, 1, NULL) == TRUE);
    assert (thrift_buffered_transport_flush (transport, NULL) == FALSE);

    thrift_buffered_transport_close (transport, NULL);

    g_object_unref (transport);
    g_object_unref (tsocket);

    assert ( wait (&status) == pid );
    assert ( status == 0 );
  }
}
Example #2
0
int main(int argc, char **argv)
{
    signal(SIGCHLD, SIG_IGN);
    signal(SIGSEGV, terminationHandler);
    fl_init_locale_support("eworkpanel", PREFIX"/share/locale");
    fl_init_images_lib();

    int X=0,Y=0,W=Fl::w(),H=Fl::h();
    int substract;

    // Get current workarea
    Fl_WM::get_workarea(X,Y,W,H);

    //printf("Free area: %d %d %d %d\n", X,Y,W,H);

    // We expect that other docks are moving away from panel :)
    mPanelWindow = new Fl_Update_Window(X, Y+H-30, W, 30, "Workpanel");
    mPanelWindow->layout_spacing(0);
    // Panel is type DOCK
    mPanelWindow->window_type(Fl_WM::DOCK);
    mPanelWindow->setAutoHide(0);

    // Read config
    bool doShowDesktop;
    pGlobalConfig.get("Panel", "ShowDesktop", doShowDesktop, false);
    bool doWorkspaces;
    pGlobalConfig.get("Panel", "Workspaces", doWorkspaces, true);
    bool doRunBrowser;
    pGlobalConfig.get("Panel", "RunBrowser", doRunBrowser, true);    
    bool doSoundMixer;
    pGlobalConfig.get("Panel", "SoundMixer", doSoundMixer, true);
    bool doCpuMonitor;
    pGlobalConfig.get("Panel", "CPUMonitor", doCpuMonitor, true);
    
    // Group that holds everything..
    Fl_Group *g = new Fl_Group(0,0,0,0);
    g->box(FL_DIV_UP_BOX);
    g->layout_spacing(2);
    g->layout_align(FL_ALIGN_CLIENT);
    g->begin();

    mSystemMenu = new MainMenu();

    Fl_VertDivider *v = new Fl_VertDivider(0, 0, 5, 18, "");
    v->layout_align(FL_ALIGN_LEFT);
    substract = 5;

    if ((doShowDesktop) || (doWorkspaces)) {
	//this is ugly:
	int size;
	if ((doShowDesktop) && (doWorkspaces)) { size=48; } else { size=24; }
	Fl_Group *g2 = new Fl_Group(0,0,size,22);
	g2->box(FL_FLAT_BOX);
	g2->layout_spacing(0);
	g2->layout_align(FL_ALIGN_LEFT);

	// Show desktop button
	if (doShowDesktop) {
		PanelButton *mShowDesktop;
		mShowDesktop = new PanelButton(0, 0, 24, 22, FL_NO_BOX, FL_DOWN_BOX, "ShowDesktop");
		mShowDesktop->layout_align(FL_ALIGN_LEFT);
		mShowDesktop->label_type(FL_NO_LABEL);
		mShowDesktop->align(FL_ALIGN_INSIDE|FL_ALIGN_CENTER);
		mShowDesktop->image(showdesktop_pix);
		mShowDesktop->tooltip(_("Show desktop"));
		mShowDesktop->callback( (Fl_Callback*)cb_showdesktop);
		mShowDesktop->show();
		
		substract += 26;
	}
    
	// Workspaces panel
	if (doWorkspaces) {
		mWorkspace = new PanelMenu(0, 0, 24, 22, FL_NO_BOX, FL_DOWN_BOX, "WSMenu");
		mWorkspace->layout_align(FL_ALIGN_LEFT);
		mWorkspace->label_type(FL_NO_LABEL);
		mWorkspace->align(FL_ALIGN_INSIDE|FL_ALIGN_CENTER);
		mWorkspace->image(desktop_pix);
		mWorkspace->tooltip(_("Workspaces"));
		mWorkspace->end();
		
		substract += 26;
	}
	
	g2->end();
	g2->show();
	g2->resizable();

	v = new Fl_VertDivider(0, 0, 5, 18, "");
        v->layout_align(FL_ALIGN_LEFT);
	substract += 5;
    }
    
    // Run browser
    if (doRunBrowser) {
        runBrowser = new Fl_Input_Browser("",100,FL_ALIGN_LEFT,30);
        //runBrowser->image(run_pix);
        //runBrowser->box(FL_THIN_DOWN_BOX);

        // Added _ALWAYS so callback is in case:
        // 1) select old command from input browser
        // 2) press enter to execute. (this won't work w/o _ALWAYS)
//        runBrowser->input()->when(FL_WHEN_ENTER_KEY_ALWAYS | FL_WHEN_RELEASE_ALWAYS); 
        // Vedran: HOWEVER, with _ALWAYS cb_run_app will be called way
        // too many times, causing fork-attack
        runBrowser->input()->when(FL_WHEN_ENTER_KEY); 
        runBrowser->input()->callback((Fl_Callback*)cb_run_app);
        runBrowser->callback((Fl_Callback*)cb_run_app2);

        v = new Fl_VertDivider(0, 0, 5, 18, "");
        v->layout_align(FL_ALIGN_LEFT);
	substract += 105;
    }


    // Popup menu for the whole taskbar
    Fl_Menu_Button *mPopupPanelProp = new Fl_Menu_Button( 0, 0, W, 28 );
    mPopupPanelProp->type( Fl_Menu_Button::POPUP3 );
    mPopupPanelProp->anim_flags(Fl_Menu_::LEFT_TO_RIGHT);
    mPopupPanelProp->anim_speed(0.8);
    mPopupPanelProp->begin();

    Fl_Item *mPanelSettings = new Fl_Item(_("Settings"));
    mPanelSettings->x_offset(12);
    mPanelSettings->callback( (Fl_Callback*)runUtility, (void*)"epanelconf" );
    new Fl_Divider(10, 5);

    Fl_Item *mAboutItem = new Fl_Item(_("About EDE..."));
    mAboutItem->x_offset(12);
    mAboutItem->callback( (Fl_Callback *)AboutDialog );

    mPopupPanelProp->end();

    // Subgroup to properly align everything
/*    Fl_Group *subgroup;
    {
        subgroup = new Fl_Group(0, 0, W-substract, 18);
        subgroup->box(FL_FLAT_BOX);
        subgroup->layout_align(FL_ALIGN_RIGHT);
        subgroup->show();
        subgroup->begin(); */
    
        // Taskbar...
        tasks = new TaskBar();
        dock = new Dock();

        v = new Fl_VertDivider(0, 0, 5, 18, "");
        v->layout_align(FL_ALIGN_RIGHT);
    
/*        subgroup->end();
    }*/

    {
        // MODEM
        mModemLeds = new Fl_Group(0, 0, 25, 18);
        mModemLeds->box(FL_FLAT_BOX);
        mModemLeds->hide();
        mLedIn = new Fl_Box(2, 5, 10, 10);
        mLedIn->box( FL_OVAL_BOX );
        mLedIn->color( (Fl_Color)968701184);
        mLedOut = new Fl_Box(12, 5, 10, 10);
        mLedOut->box( FL_OVAL_BOX);
        mLedOut->color( (Fl_Color)968701184);
        mModemLeds->end();
    }

    {
        // KEYBOARD SELECT
        mKbdSelect = new KeyboardChooser(0, 0, 20, 18, FL_NO_BOX, FL_DOWN_BOX, "us");
        mKbdSelect->hide();
        mKbdSelect->anim_speed(4);
        mKbdSelect->label_font(mKbdSelect->label_font()->bold());
        mKbdSelect->highlight_color(mKbdSelect->selection_color());
        mKbdSelect->highlight_label_color( mKbdSelect->selection_text_color());
    }

    {
        // CLOCK
        mClockBox = new Fl_Button(0, 0, 50, 20);
        mClockBox->align(FL_ALIGN_INSIDE|FL_ALIGN_LEFT);
        mClockBox->hide();
        mClockBox->box(FL_FLAT_BOX);
        mClockBox->callback( (Fl_Callback*)startUtility, (void*)"Time and date");
    }
 
    dock->add_to_tray(mClockBox);
    dock->add_to_tray(mKbdSelect);
    
    // SOUND applet
    if (doSoundMixer) {
        Fl_Button *mSoundMixer;
        mSoundMixer = new Fl_Button(0, 0, 20, 18);
        mSoundMixer->hide();
        mSoundMixer->box(FL_NO_BOX);
        mSoundMixer->focus_box(FL_NO_BOX);
        mSoundMixer->image(sound_pix);
        mSoundMixer->tooltip(_("Volume control"));
        mSoundMixer->align(FL_ALIGN_INSIDE);
        mSoundMixer->callback( (Fl_Callback*)startUtility, (void*)"Volume Control" );
        dock->add_to_tray(mSoundMixer);
    }

    // CPU monitor
    if (doCpuMonitor) {
        CPUMonitor *cpumon;
        cpumon = new CPUMonitor();
        cpumon->hide();
        dock->add_to_tray(cpumon);
    }


    Fl::focus(mSystemMenu);

    mPanelWindow->end();
    mPanelWindow->show(argc, argv);

    Fl_WM::callback(FL_WM_handler, 0, Fl_WM::DESKTOP_COUNT | 
		    					   Fl_WM::DESKTOP_NAMES |
							   Fl_WM::DESKTOP_CHANGED|
							   Fl_WM::WINDOW_LIST|
							   Fl_WM::WINDOW_DESKTOP|
							   Fl_WM::WINDOW_ACTIVE|
							   Fl_WM::WINDOW_NAME|
							   Fl_WM::WINDOW_ICONNAME);

    updateWorkspaces(0,0);

    Fl::add_timeout(0, clockRefresh);
    Fl::add_timeout(0, updateStats);

    while(mPanelWindow->shown())
        Fl::wait();
}
Example #3
0
int lurk()
{
    wav_file in, out;
    int quit;
    int16_t *buffer;
    int buffer_length, buffer_bytes, read_length;
    uint64_t total_length, cut_length, peak_length;
    int recording;
    char *output_path, *output_temp_path;
    double rms;
    const char progress[] = {'|', '/', '-', '\\'};
    uint64_t progress_temp, progress_position;

    quit = 0;
    terminate_signal = 0;
    output_path = NULL;
    output_temp_path = NULL;
    progress_position = 0;
    
    printf("Reading header from %s\n", (input == NULL ? "stdin" : input));

    if(wav_open_read(input, &in) == -1)
    {
        fprintf(stderr, "Failed to open %s for input\n", input);

        return -1;
    }
    
    if(!(in.format.audio_format == 1 && /* 1 = PCM */
         in.format.bits_per_sample == 16 &&
         in.format.num_channels == 1))
    {
        fprintf(stderr, "Wrong audio format, i want 16 bit mono PCM audio\n");

        return -1;
    }
    
    printf("Output: %s\n", output);
    printf("Recording append: %s\n", recording_append);
    printf("Threshold: %g\n", threshold);
    printf("Runlength: %g seconds\n", runlength);
    if(short_filter != 0)
        printf("Short filter: %g seconds\n", short_filter);
   
    buffer_length = in.format.sample_rate / slice_divisor;
    buffer_bytes = buffer_length * in.format.block_align;
    buffer = malloc(buffer_bytes);
    if(buffer == NULL)
    {
        fprintf(stderr, "lurk: malloc audio buffer failed\n");

        return -1;
    }
    total_length = 0;
    cut_length = 0;
    peak_length = 0;
    recording = 0;

    if(time_start != 0)
    {
        char s[256];
        
        strftime(s, sizeof(s), "%Y-%m-%d %H:%M:%S", localtime(&time_start));
        printf("Start time: %s\n", s);
    }
    printf("Sample rate: %d Hz\n", in.format.sample_rate);
    printf("Slice divisor: %g\n", slice_divisor);
    printf("\n");
    printf("Starting to lurk...\n");
    
    signal(SIGINT, signal_handler);
    signal(SIGTERM, signal_handler);
    
    while(quit == 0)
    {
        read_length = riff_read_wave_16(in.stream, buffer, buffer_length);
        if(read_length < 1)
        {
            if(read_length == 0)
            {
                if(recording == 1)
                    quit = 1; /* run loop one last time */
                else
                    break;
            }
            else
            {
                fprintf(stderr, "Error reading input file\n");

                if(recording == 1)
                {
                    message("Trying to close output file nicely\n");
                    wav_close_write(&out);
                    rename(output_temp_path, output_path);
                }

                break;
            }
        }

        if(terminate_signal == 1)
            quit = 1;
        
        rms = root_mean_square(buffer, read_length);
        total_length += read_length;
        
        if(recording == 1)
        {
            if((double)peak_length / in.format.sample_rate > runlength || quit == 1)
            {
                /* stop recording to file */
                recording = 0;

                /* remove runlength seconds of silence at end of recording */
                cut_length -= runlength * in.format.sample_rate;
                /* adjust file */
                wav_truncate(&out, cut_length * out.format.block_align);
                
                if(wav_close_write(&out) == -1)
                    fprintf(stderr, "lurk: failed to close output file %s\n", output_temp_path);
                
                if(short_filter != 0 &&
                   (double)cut_length / in.format.sample_rate < short_filter)
                {
                    if(unlink(output_temp_path) == -1)
                        fprintf(stderr, "lurk: faild to unlink %s\n", output_temp_path);
                    
                    message("Recording removed, short filter\n");
                }
                else
                {
                    if(rename(output_temp_path, output_path) == -1)
                        fprintf(stderr, "lurk: faild to rename %s to %s\n", output_temp_path, output_path);
                    
                    message("Recording stopped, %d minutes %d seconds recorded\n",
                            (int)(cut_length / in.format.sample_rate) / 60,
                            /* (int)(ceil(cut_length / in.format.sample_rate)) % 60 */
                            (int)(cut_length / in.format.sample_rate) % 60
                            );
                }
                
                free(output_path);
                free(output_temp_path);
                output_path = NULL;
                output_temp_path = NULL;
                cut_length = 0;
                peak_length = 0;
            }
            else
            {
                cut_length += read_length;
                peak_length += read_length;

                if(rms > threshold)
                    peak_length = 0;
            }
        }
        else
        {
            if(rms > threshold)
            {
                time_t t;
                char *s, *d;
                char expanded[PATH_MAX];
                
                /* start recording to file */
                recording = 1;

                /* fancy print output path (non-absolute path etc) */
                if(time_start != 0)
                    t = time_start + total_length / in.format.sample_rate;
                else
                    time(&t);
                strftime(expanded, sizeof(expanded), output, localtime(&t));
                message("Recording started to %s\n", expanded);

                if(asprintf(&output_path, "%s%s",
                            (output[0] == '/' ? "" : current_dir), /* make absolute if relative */
                            expanded
                            ) == -1)
                {
                    fprintf(stderr, "lurk: asprintf failed: output_path\n");

                    return -1;
                }
                if(asprintf(&output_temp_path, "%s%s",
                            output_path,
                            recording_append
                            ) == -1)
                {
                    fprintf(stderr, "lurk: asprintf failed: output_temp_path\n");

                    return -1;
                }
                
                s = strdup(output_path);
                if(s == NULL)
                {
                    fprintf(stderr, "lurk: strdup failed: output_path\n");

                    return -1;
                }
                d = dirname(s);
                if(mkdirp(d) == -1)
                {
                    fprintf(stderr, "lurk: mkdirp failed: %s\n", d);

                    return -1;
                }
                free(s);
                
                out.riff.size = INT32_MAX; /* as big as possible, wav_close_write will fix them */
                out.data.size = INT32_MAX;
                out.format.audio_format = 1; /* PCM */
                out.format.num_channels = 1; /* mono */
                out.format.sample_rate = in.format.sample_rate;
                out.format.byte_rate = in.format.byte_rate;
                out.format.block_align = in.format.block_align;
                out.format.bits_per_sample = in.format.bits_per_sample;

                if(wav_open_write(output_temp_path, &out) == -1)
                {
                    fprintf(stderr, "lurk: failed to open temp output file %s\n", output_temp_path);

                    return -1;
                }
            }
        }
/*
        progress_temp = total_length / in.format.sample_rate;
        if(progress_temp > progress_position)
        {
            progress_position = progress_temp;
            message("%s %c",
                   (recording == 1 ? "Recording" : "Lurking"),
                   progress[progress_position % sizeof(progress)]
                   );

            fflush(stdout);
        }
*/        

        /* bloated fancy status featuring cut length, volume-meter and more! */
        {
            int p, l;
            char b[21];
            
            progress_position = total_length / in.format.sample_rate;
            
            l = sizeof(b) * rms;
            for(p = 0; p < sizeof(b) - 1; p++)
                b[p] = (p < l ? '=' : ' ');
            b[sizeof(b) - 1] = '\0';
            
            message("%s %c [t:%.1f c:%.1f p:%.1f] [%s]",
                   (recording == 1 ? "Recording" : "Lurking"),
                   progress[progress_position % sizeof(progress)],
                   (double)total_length / in.format.sample_rate,
                   (double)cut_length / in.format.sample_rate,
                   (double)peak_length / in.format.sample_rate,
                   b
                   );
            
            fflush(stdout);
        }
        
        if(recording == 1)
        {
            /* write audio to file */
            if(riff_write_wave_16(out.stream, buffer, read_length) == -1)
            {
                fprintf(stderr, "lurk: riff_write_wave_16 failed\n");

                return -1;
            }
        }
    }

    wav_close_read(&in);
    free(buffer);
    if(output_path != NULL)
        free(output_path);
    if(output_temp_path != NULL)
        free(output_temp_path);
    
    message("Stopped\n");

    return 0;
}
Example #4
0
int main(int argc, char **argv) {
  struct pk_manager *m;
  unsigned int tmp_uint;
  int gotargs = 0;
  int verbosity = 0;
  int use_ipv4 = 1;
#ifdef HAVE_IPV6
  int use_ipv6 = 1;
#endif
  int use_evil = 0;
  int use_watchdog = 0;
  int max_conns = 25;
  int lport;
  int ac;
  SSL_CTX* ssl_ctx;

  /* FIXME: Is this too lame? */
  srand(time(0) ^ getpid());
  pks_global_init(PK_LOG_NORMAL);

  while (-1 != (ac = getopt(argc, argv, "46a:c:B:E:qvWZ"))) {
    switch (ac) {
      case '4':
        use_ipv4 = 0;
        break;
      case '6':
#ifdef HAVE_IPV6
        use_ipv6 = 0;
#endif
        break;
      case 'v':
        verbosity++;
        break;
      case 'q':
        verbosity--;
        break;
      case 'W':
        use_watchdog = 1;
        break;
      case 'Z':
        use_evil = 1;
        break;
      case 'B':
        gotargs++;
        if (1 == sscanf(optarg, "%u", &pk_state.bail_on_errors)) break;
        usage(EXIT_ERR_USAGE);
      case 'c':
        gotargs++;
        if (1 == sscanf(optarg, "%d", &max_conns)) break;
        usage(EXIT_ERR_USAGE);
      case 'E':
        gotargs++;
        if (1 == sscanf(optarg, "%u", &tmp_uint)) {
          pk_state.conn_eviction_idle_s = tmp_uint;
          break;
        }
        usage(EXIT_ERR_USAGE);
      default:
        usage(EXIT_ERR_USAGE);
    }
    gotargs++;
  }

  if ((argc-1-gotargs) < 5 || ((argc-1-gotargs) % 5) != 0) {
    usage(EXIT_ERR_USAGE);
  }

  signal(SIGUSR1, &raise_log_level);

  pk_state.log_mask = ((verbosity < 0) ? PK_LOG_ERRORS :
                      ((verbosity < 1) ? PK_LOG_NORMAL :
                      ((verbosity < 2) ? PK_LOG_DEBUG : PK_LOG_ALL)));

  PKS_SSL_INIT(ssl_ctx);

  if (NULL == (m = pkm_manager_init(NULL, 0, NULL, 0,
                                    PAGEKITE_NET_CLIENT_MAX,
                                    max_conns, NULL, ssl_ctx))) {
    pk_perror(argv[0]);
    exit(EXIT_ERR_MANAGER_INIT);
  }
  if (use_evil) {
    m->housekeeping_interval_min = 5;
    m->housekeeping_interval_max = 20;
    m->check_world_interval = 30;
  }
  if (use_watchdog)
    m->enable_watchdog = 1;

  for (ac = gotargs; ac < argc; ac += 1) {
    if (1 == sscanf(argv[ac+1], "%d", &lport)) {
      if (use_ipv4)
        if (NULL == (pkr_add_listener(m, lport))) {
          pk_perror(argv[0]);
          exit(EXIT_ERR_ADD_LPORT);
        }
#ifdef HAVE_IPV6
      if (use_ipv6)
        if (NULL == (pkr_add_listener_v6(m, lport))) {
          pk_perror(argv[0]);
          exit(EXIT_ERR_ADD_LPORT);
        }
#endif
    } else {
      break;
    }
  }

  for (; ac+2 < argc; ac += 2) {
    if (NULL == (pkm_add_kite(m, NULL, argv[ac+1], 0, argv[ac+2], NULL, 0))) {
      pk_perror(argv[0]);
      exit(EXIT_ERR_ADD_KITE);
    }
  }

  if (0 > pkm_run_in_thread(m)) {
    pk_perror(argv[0]);
    exit(EXIT_ERR_START_THREAD);
  }

  pkm_wait_thread(m);

  return 0;
}
Example #5
0
int
main(int argc, char *argv[])
{
	int ch;
	time_t secs = 0, t;
	char *cp;
	long nsecs = 0;
	struct timespec rqtp;
	int i;

	if (pledge("stdio", NULL) == -1)
		err(1, "pledge");

	signal(SIGALRM, alarmh);

	while ((ch = getopt(argc, argv, "")) != -1)
		switch(ch) {
		default:
			usage();
		}
	argc -= optind;
	argv += optind;

	if (argc != 1)
		usage();

	cp = *argv;
	while ((*cp != '\0') && (*cp != '.')) {
		if (!isdigit((unsigned char)*cp))
			usage();
		t = (secs * 10) + (*cp++ - '0');
		if (t / 10 != secs)	/* oflow */
			return (EINVAL);
		secs = t;
	}

	/* Handle fractions of a second */
	if (*cp == '.') {
		cp++;
		for (i = 100000000; i > 0; i /= 10) {
			if (*cp == '\0')
				break;
			if (!isdigit((unsigned char)*cp))
				usage();
			nsecs += (*cp++ - '0') * i;
		}

		/*
		 * We parse all the way down to nanoseconds
		 * in the above for loop. Be pedantic about
		 * checking the rest of the argument.
		 */
		while (*cp != '\0') {
			if (!isdigit((unsigned char)*cp++))
				usage();
		}
	}

	rqtp.tv_sec = secs;
	rqtp.tv_nsec = nsecs;

	if ((secs > 0) || (nsecs > 0))
		if (nanosleep(&rqtp, NULL))
			err(1, NULL);
	return (0);
}
Example #6
0
/* main -- dnsproxy main function
 */
int
main(int argc, char *argv[])
{
    int ch;
    struct passwd *pw = NULL;
    struct sockaddr_in addr;
    struct event evq, eva;
    const char *config = "/etc/dnsproxy.conf";
    int daemonize = 0;

    /* Process commandline arguments */
    while ((ch = getopt(argc, argv, "c:dhV")) != -1) {
        switch (ch) {
        case 'c':
            config = optarg;
            break;
        case 'd':
            daemonize = 1;
            break;
        case 'V':
            fprintf(stderr, PACKAGE_STRING "\n");
            exit(0);
        /* FALLTHROUGH */
        case 'h':
        default:
            fprintf(stderr,
            "usage: dnsproxy [-c file] [-dhV]\n"        \
            "\t-c file  Read configuration from file\n" \
            "\t-d       Detach and run as a daemon\n"   \
            "\t-h       This help text\n"           \
            "\t-V       Show version information\n");
            exit(1);
        }
    }

    /* Parse configuration and check required parameters */
    if (!parse(config))
        fatal("unable to parse configuration");

    if (!authoritative || !recursive)
        fatal("No authoritative or recursive server defined");

    if (!listenat)
        listenat = strdup("0.0.0.0");

    /* Create and bind query socket */
    if ((sock_query = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
        fatal("unable to create socket: %s", strerror(errno));

    memset(&addr, 0, sizeof(struct sockaddr_in));
    addr.sin_addr.s_addr = inet_addr(listenat);
    addr.sin_port = htons(port);
    addr.sin_family = AF_INET;

    if (bind(sock_query, (struct sockaddr *)&addr, sizeof(addr)) != 0)
        fatal("unable to bind socket: %s", strerror(errno));

    /* Create and bind answer socket */
    if ((sock_answer = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
        fatal("unable to create socket: %s", strerror(errno));

    memset(&addr, 0, sizeof(struct sockaddr_in));
    addr.sin_family = AF_INET;

    if (bind(sock_answer, (struct sockaddr *)&addr, sizeof(addr)) != 0)
        fatal("unable to bind socket: %s", strerror(errno));

    /* Fill sockaddr_in structs for both servers */
    memset(&authoritative_addr, 0, sizeof(struct sockaddr_in));
    authoritative_addr.sin_addr.s_addr = inet_addr(authoritative);
    authoritative_addr.sin_port = htons(authoritative_port);
    authoritative_addr.sin_family = AF_INET;

    memset(&recursive_addr, 0, sizeof(struct sockaddr_in));
    recursive_addr.sin_addr.s_addr = inet_addr(recursive);
    recursive_addr.sin_port = htons(recursive_port);
    recursive_addr.sin_family = AF_INET;

    /* Daemonize if requested and switch to syslog */
    if (daemonize) {
        if (daemon(0, 0) == -1)
            fatal("unable to daemonize");
        log_syslog("dnsproxy");
    }

    /* Find less privileged user */
    if (user) {
        pw = getpwnam(user);
        if (!pw)
            fatal("unable to find user %s", user);
    }

    /* Do a chroot if requested */
    if (chrootdir) {
        if (chdir(chrootdir) || chroot(chrootdir))
            fatal("unable to chroot to %s", chrootdir);
        chdir("/");
    }

    /* Drop privileges */
    if (user) {
        if (setgroups(1, &pw->pw_gid) < 0)
            fatal("setgroups: %s", strerror(errno));
#if defined(HAVE_SETRESGID)
        if (setresgid(pw->pw_gid, pw->pw_gid, pw->pw_gid) < 0)
            fatal("setresgid: %s", strerror(errno));
#elif defined(HAVE_SETREGID)
        if (setregid(pw->pw_gid, pw->pw_gid) < 0)
            fatal("setregid: %s", strerror(errno));
#else
        if (setegid(pw->pw_gid) < 0)
            fatal("setegid: %s", strerror(errno));
        if (setgid(pw->pw_gid) < 0)
            fatal("setgid: %s", strerror(errno));
#endif
#if defined(HAVE_SETRESUID)
        if (setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid) < 0)
            fatal("setresuid: %s", strerror(errno));
#elif defined(HAVE_SETREUID)
        if (setreuid(pw->pw_uid, pw->pw_uid) < 0)
            fatal("setreuid: %s", strerror(errno));
#else
        if (seteuid(pw->pw_uid) < 0)
            fatal("seteuid: %s", strerror(errno));
        if (setuid(pw->pw_uid) < 0)
            fatal("setuid: %s", strerror(errno));
#endif
    }

    /* Init event handling */
    event_init();

    event_set(&evq, sock_query, EV_READ, do_query, &evq);
    event_add(&evq, NULL);

    event_set(&eva, sock_answer, EV_READ, do_answer, &eva);
    event_add(&eva, NULL);

    /* Zero counters and start statistics timer */
    statistics_start();

    /* Take care of signals */
    if (signal(SIGINT, signal_handler) == SIG_ERR)
        fatal("unable to mask signal SIGINT: %s", strerror(errno));

    if (signal(SIGTERM, signal_handler) == SIG_ERR)
        fatal("unable to mask signal SIGTERM: %s", strerror(errno));

    if (signal(SIGHUP, SIG_IGN) == SIG_ERR)
        fatal("unable to mask signal SIGHUP: %s", strerror(errno));

    event_sigcb = signal_event;

    /* Start libevent main loop */
    event_dispatch();

    return 0;

}
Example #7
0
File: main.c Project: WndSks/msys
int
main(int argc, char **argv)
{
	int c;
	char *scan;
	/* the + on the front tells GNU getopt not to rearrange argv */
	const char *optlist = "+F:f:v:W;m:D";
	int stopped_early = FALSE;
	int old_optind;
	extern int optind;
	extern int opterr;
	extern char *optarg;
	int i;
	int stdio_problem = FALSE;

	/* do these checks early */
	if (getenv("TIDYMEM") != NULL)
		do_tidy_mem = TRUE;

	if (getenv("WHINY_USERS") != NULL)
		whiny_users = TRUE;

#ifdef HAVE_MCHECK_H
	if (do_tidy_mem)
		mtrace();
#endif /* HAVE_MCHECK_H */
	
#if defined(LC_CTYPE)
	setlocale(LC_CTYPE, "");
#endif
#if defined(LC_COLLATE)
	setlocale(LC_COLLATE, "");
#endif
#if defined(LC_MESSAGES)
	setlocale(LC_MESSAGES, "");
#endif
#if defined(LC_NUMERIC)
	/*
	 * Force the issue here.  According to POSIX 2001, decimal
	 * point is used for parsing source code and for command-line
	 * assignments and the locale value for processing input,
	 * number to string conversion, and printing output.
	 */
	setlocale(LC_NUMERIC, "C");
#endif
#if defined(LC_TIME)
	setlocale(LC_TIME, "");
#endif

#ifdef MBS_SUPPORT
	/*
	 * In glibc, MB_CUR_MAX is actually a function.  This value is
	 * tested *a lot* in many speed-critical places in gawk. Caching
	 * this value once makes a speed difference.
	 */
	gawk_mb_cur_max = MB_CUR_MAX;
	/* Without MBS_SUPPORT, gawk_mb_cur_max is 1. */
#endif

	(void) bindtextdomain(PACKAGE, LOCALEDIR);
	(void) textdomain(PACKAGE);

	(void) signal(SIGFPE, catchsig);
	(void) signal(SIGSEGV, catchsig);
#ifdef SIGBUS
	(void) signal(SIGBUS, catchsig);
#endif

	myname = gawk_name(argv[0]);
        argv[0] = (char *) myname;
	os_arg_fixup(&argc, &argv); /* emulate redirection, expand wildcards */

	/* remove sccs gunk */
	if (strncmp(version_string, "@(#)", 4) == 0)
		version_string += 4;

	if (argc < 2)
		usage(1, stderr);

	/* Robustness: check that file descriptors 0, 1, 2 are open */
	init_fds();

	/* init array handling. */
	array_init();

	/* we do error messages ourselves on invalid options */
	opterr = FALSE;

	/* option processing. ready, set, go! */
	for (optopt = 0, old_optind = 1;
	     (c = getopt_long(argc, argv, optlist, optab, NULL)) != EOF;
	     optopt = 0, old_optind = optind) {
		if (do_posix)
			opterr = TRUE;

		switch (c) {
		case 'F':
			preassigns_add(PRE_ASSIGN_FS, optarg);
			break;

		case 'S':
			disallow_var_assigns = TRUE;
			/* fall through */
		case 'f':
			/*
			 * a la MKS awk, allow multiple -f options.
			 * this makes function libraries real easy.
			 * most of the magic is in the scanner.
			 *
			 * The following is to allow for whitespace at the end
			 * of a #! /bin/gawk line in an executable file
			 */
			scan = optarg;
			if (argv[optind-1] != optarg)
				while (ISSPACE(*scan))
					scan++;
			srcfiles_add(SOURCEFILE,
				(*scan == '\0' ? argv[optind++] : optarg));
			break;

		case 'v':
			preassigns_add(PRE_ASSIGN, optarg);
			break;

		case 'm':
			/*
			 * Research awk extension.
			 *	-mf nnn		set # fields, gawk ignores
			 *	-mr nnn		set record length, ditto
			 */
			if (do_lint)
				lintwarn(_("`-m[fr]' option irrelevant in gawk"));
			if (optarg[0] != 'r' && optarg[0] != 'f')
				warning(_("-m option usage: `-m[fr] nnn'"));
			/*
			 * Set fixed length records for Tandem,
			 * ignored on other platforms (see io.c:get_a_record).
			 */
			if (optarg[0] == 'r') {
				if (ISDIGIT(optarg[1]))
					MRL = atoi(optarg+1);
				else {
					MRL = atoi(argv[optind]);
					optind++;
				}
			} else if (optarg[1] == '\0')
				optind++;
			break;

		case 'W':       /* gawk specific options - now in getopt_long */
			fprintf(stderr, _("%s: option `-W %s' unrecognized, ignored\n"),
				argv[0], optarg);
			break;

		/* These can only come from long form options */
		case 'C':
			copyleft();
			break;

		case 'd':
			do_dump_vars = TRUE;
			if (optarg != NULL && optarg[0] != '\0')
				varfile = optarg;
			break;

		case 'l':
#ifndef NO_LINT
			do_lint = LINT_ALL;
			if (optarg != NULL) {
				if (strcmp(optarg, "fatal") == 0)
					lintfunc = r_fatal;
				else if (strcmp(optarg, "invalid") == 0)
					do_lint = LINT_INVALID;
			}
#endif
			break;

		case 'p':
			do_profiling = TRUE;
			if (optarg != NULL)
				set_prof_file(optarg);
			else
				set_prof_file(DEFAULT_PROFILE);
			break;

		case 's':
			if (optarg[0] == '\0')
				warning(_("empty argument to `--source' ignored"));
			else
				srcfiles_add(CMDLINE, optarg);
			break;

		case 'u':
			usage(0, stdout);	/* per coding stds */
			break;

		case 'V':
			version();
			break;

		case 0:
			/*
			 * getopt_long found an option that sets a variable
			 * instead of returning a letter. Do nothing, just
			 * cycle around for the next one.
			 */
			break;

		case 'D':
#ifdef GAWKDEBUG
			yydebug = 2;
			break;
#endif
			/* if not debugging, fall through */

		case '?':
		default:
			/*
			 * New behavior.  If not posix, an unrecognized
			 * option stops argument processing so that it can
			 * go into ARGV for the awk program to see. This
			 * makes use of ``#! /bin/gawk -f'' easier.
			 *
			 * However, it's never simple. If optopt is set,
			 * an option that requires an argument didn't get the
			 * argument. We care because if opterr is 0, then
			 * getopt_long won't print the error message for us.
			 */
			if (! do_posix
			    && (optopt == '\0' || strchr(optlist, optopt) == NULL)) {
				/*
				 * can't just do optind--. In case of an
				 * option with >= 2 letters, getopt_long
				 * won't have incremented optind.
				 */
				optind = old_optind;
				stopped_early = TRUE;
				goto out;
			} else if (optopt != '\0')
				/* Use 1003.2 required message format */
				fprintf(stderr,
					_("%s: option requires an argument -- %c\n"),
					myname, optopt);
			/* else
				let getopt print error message for us */
			break;
		}
		if (c == 'S')	/* --exec ends option processing */
			break;
	}
out:

	if (do_nostalgia)
		nostalgia();

	/* check for POSIXLY_CORRECT environment variable */
	if (! do_posix && getenv("POSIXLY_CORRECT") != NULL) {
		do_posix = TRUE;
		if (do_lint)
			lintwarn(
	_("environment variable `POSIXLY_CORRECT' set: turning on `--posix'"));
	}

	if (do_posix) {
		if (do_traditional)	/* both on command line */
			warning(_("`--posix' overrides `--traditional'"));
		else
			do_traditional = TRUE;
			/*
			 * POSIX compliance also implies
			 * no GNU extensions either.
			 */
	}

	if (do_traditional && do_non_decimal_data) {
		do_non_decimal_data = FALSE;
		warning(_("`--posix'/`--traditional' overrides `--non-decimal-data'"));
	}

	if (do_lint && os_is_setuid())
		warning(_("running %s setuid root may be a security problem"), myname);

	/*
	 * Force profiling if this is pgawk.
	 * Don't bother if the command line already set profiling up.
	 */
	if (! do_profiling)
		init_profiling(& do_profiling, DEFAULT_PROFILE);

	/* load group set */
	init_groupset();

	/* initialize the null string */
	Nnull_string = make_string("", 0);
	Nnull_string->numbr = 0.0;
	Nnull_string->type = Node_val;
	Nnull_string->flags = (PERM|STRCUR|STRING|NUMCUR|NUMBER);

	/*
	 * Tell the regex routines how they should work.
	 * Do this before initializing variables, since
	 * they could want to do a regexp compile.
	 */
	resetup();

	/* Set up the special variables */
	init_vars();

	/* Set up the field variables */
	init_fields();

	/* Now process the pre-assignments */
	for (i = 0; i <= numassigns; i++)
		if (preassigns[i].stype == PRE_ASSIGN)
			(void) arg_assign(preassigns[i].val, TRUE);
		else	/* PRE_ASSIGN_FS */
			cmdline_fs(preassigns[i].val);
	free(preassigns);

	if ((BINMODE & 1) != 0)
		if (os_setbinmode(fileno(stdin), O_BINARY) == -1)
			fatal(_("can't set binary mode on stdin (%s)"), strerror(errno));
	if ((BINMODE & 2) != 0) {
		if (os_setbinmode(fileno(stdout), O_BINARY) == -1)
			fatal(_("can't set binary mode on stdout (%s)"), strerror(errno));
		if (os_setbinmode(fileno(stderr), O_BINARY) == -1)
			fatal(_("can't set binary mode on stderr (%s)"), strerror(errno));
	}

#ifdef GAWKDEBUG
	setbuf(stdout, (char *) NULL);	/* make debugging easier */
#endif
	if (isatty(fileno(stdout)))
		output_is_tty = TRUE;
	/* No -f or --source options, use next arg */
	if (numfiles == -1) {
		if (optind > argc - 1 || stopped_early) /* no args left or no program */
			usage(1, stderr);
		srcfiles_add(CMDLINE, argv[optind]);
		optind++;
	}

	init_args(optind, argc, (char *) myname, argv);
	(void) tokexpand();

#if defined(LC_NUMERIC)
	/*
	 * FRAGILE!  CAREFUL!
	 * Pre-initing the variables with arg_assign() can change the
	 * locale.  Force it to C before parsing the program.
	 */
	setlocale(LC_NUMERIC, "C");
#endif

	/* Read in the program */
	if (yyparse() != 0 || errcount != 0)
		exit(1);

	free(srcfiles);

	if (do_intl)
		exit(0);

	if (do_lint && begin_block == NULL && expression_value == NULL
	     && end_block == NULL)
		lintwarn(_("no program text at all!"));

	if (do_lint)
		shadow_funcs();

	init_profiling_signals();

#if defined(LC_NUMERIC)
	/* See comment above. */
	setlocale(LC_NUMERIC, "");
#endif

#if defined(HAVE_LOCALE_H)
	loc = *localeconv();	/* Make a local copy of locale numeric info */
#endif

	/* Whew. Finally, run the program. */
	if (begin_block != NULL) {
		in_begin_rule = TRUE;
		(void) interpret(begin_block);
	}
	in_begin_rule = FALSE;
	if (! exiting && (expression_value != NULL || end_block != NULL))
		do_input();
	if (end_block != NULL) {
		in_end_rule = TRUE;
		(void) interpret(end_block);
	}
	in_end_rule = FALSE;
	/*
	 * This used to be:
	 *
	 * if (close_io() != 0 && ! exiting && exit_val == 0)
	 * 	exit_val = 1;
	 *
	 * Other awks don't care about problems closing open files
	 * and pipes, in that it doesn't affect their exit status.
	 * So we no longer do either.
	 */
	(void) close_io(& stdio_problem);
	/*
	 * However, we do want to exit non-zero if there was a problem
	 * with stdout/stderr, so we reinstate a slightly different
	 * version of the above:
	 */
	if (stdio_problem && ! exiting && exit_val == 0)
		exit_val = 1;

	if (do_profiling) {
		dump_prog(begin_block, expression_value, end_block);
		dump_funcs();
	}

	if (do_dump_vars)
		dump_vars(varfile);

	if (do_tidy_mem)
		release_all_vars();

	exit(exit_val);		/* more portable */
	return exit_val;	/* to suppress warnings */
}
Example #8
0
/***********************************************************************
 *  Procedure:
 *	main - start of afterstep
 ************************************************************************/
int
main (int argc, char **argv, char **envp)
{
    register int i ;
	
	int start_viewport_x = 0 ;
	int start_viewport_y = 0 ;
	int start_desk = 0 ;

#ifdef LOCAL_DEBUG
#if 0
	LOCAL_DEBUG_OUT( "calibrating sleep_a_millisec : %s","" );
	for( i = 0 ; i < 500 ; ++i )
		sleep_a_millisec( 10 );
	LOCAL_DEBUG_OUT( "500 sliip_a_millisec(10) completed%s","" );
	for( i = 0 ; i < 50 ; ++i )
		sleep_a_millisec( 100 );
	LOCAL_DEBUG_OUT( "50 sliip_a_millisec(100) completed%s","" );
	for( i = 0 ; i < 10 ; ++i )
		sleep_a_millisec( 300 );
	LOCAL_DEBUG_OUT( "10 sliip_a_millisec(300) completed%s","" );
#endif
#endif

	_as_grab_screen_func = GrabEm;
	_as_ungrab_screen_func = UngrabEm;

	original_DISPLAY_string = getenv("DISPLAY");
	if (original_DISPLAY_string)
		original_DISPLAY_string = mystrdup(original_DISPLAY_string);

#ifdef DEBUG_TRACE_X
	trace_window_id2name_hook = &window_id2name;
#endif
	set_DeadPipe_handler(DeadPipe);

#if !HAVE_DECL_ENVIRON
	override_environ( envp );
#endif
    InitMyApp( CLASS_AFTERSTEP, argc, argv, NULL, AfterStep_usage, 0);

	LinkAfterStepConfig();

    AfterStepState = MyArgs.flags ;
    clear_flags( AfterStepState, ASS_NormalOperation );
	set_flags( AfterStepState, ASS_SuppressDeskBack );

#ifdef __CYGWIN__
    CloseOnExec = ASCloseOnExec ;
#endif

#if defined(LOG_FONT_CALLS)
	fprintf (stderr, "logging font calls now\n");
#endif

    /* These signals are mandatory : */
    signal (SIGUSR1, Restart);
    /* These signals we would like to handle only if those are not handled already (by debugger): */
    IgnoreSignal(SIGINT);
    IgnoreSignal(SIGHUP);
    IgnoreSignal(SIGQUIT);
    IgnoreSignal(SIGTERM);

    if( ConnectX( ASDefaultScr, AS_ROOT_EVENT_MASK ) < 0  )
	{
		show_error( "Hostile X server encountered - unable to proceed :-(");
		return 1;/* failed to accure window management selection - other wm is running */
	}


	ASDBus_fd = asdbus_init();

	XSetWindowBackground( dpy, Scr.Root, Scr.asv->black_pixel );
	Scr.Look.desktop_animation_tint = get_random_tint_color();

    cover_desktop();
	if( get_flags( AfterStepState, ASS_Restarting ))
	{	
		show_progress( "AfterStep v.%s is restarting ...", VERSION );
		display_progress( True, "AfterStep v.%s is restarting ...", VERSION );
	}else
	{	
    	show_progress( "AfterStep v.%s is starting up ...", VERSION );
		display_progress( True, "AfterStep v.%s is starting up ...", VERSION );
	}

	if (ASDBus_fd>=0)
	{
    	show_progress ("Successfuly accured System DBus connection.");	
		asdbus_RegisterSMClient(SMClientID_string);
	}
	
SHOW_CHECKPOINT;
	InitSession();
SHOW_CHECKPOINT;
	XSync (dpy, 0);
SHOW_CHECKPOINT;
    set_parent_hints_func( afterstep_parent_hints_func ); /* callback for collect_hints() */
SHOW_CHECKPOINT;
    SetupModules();
SHOW_CHECKPOINT;
	SetupScreen();
SHOW_CHECKPOINT;
	event_setup( True /*Bool local*/ );
SHOW_CHECKPOINT;
	/*
     *  Lets init each and every screen separately :
     */
	
    for (i = 0; i < Scr.NumberOfScreens; i++)
	{
        show_progress( "Initializing screen %d ...", i );
        display_progress( True, "Initializing screen %d ...", i );

        if (i != Scr.screen)
        {
            if( !get_flags(MyArgs.flags, ASS_SingleScreen) )
            {
                int pid = spawn_child( MyName, (i<MAX_USER_SINGLETONS_NUM)?i:-1, i, NULL, None, C_NO_CONTEXT, True, True, NULL );
                if( pid >= 0 )
                    show_progress( "\t instance of afterstep spawned with pid %d.", pid );
                else
                    show_error( "failed to launch instance of afterstep to handle screen #%d", i );
            }
        }else
        {
            make_screen_envvars(ASDefaultScr);
            putenv (Scr.rdisplay_string);
            putenv (Scr.display_string);
            if( is_output_level_under_threshold( OUTPUT_LEVEL_PROGRESS ) )
            {
                show_progress( "\t screen[%d].size = %ux%u", Scr.screen, Scr.MyDisplayWidth, Scr.MyDisplayHeight );
                display_progress( True, "    screen[%d].size = %ux%u", Scr.screen, Scr.MyDisplayWidth, Scr.MyDisplayHeight );
                show_progress( "\t screen[%d].root = %lX", Scr.screen, Scr.Root );
                show_progress( "\t screen[%d].color_depth = %d", Scr.screen, Scr.asv->true_depth );
                display_progress( True, "    screen[%d].color_depth = %d", Scr.screen, Scr.asv->true_depth );
                show_progress( "\t screen[%d].colormap    = 0x%lX", Scr.screen, Scr.asv->colormap );
                show_progress( "\t screen[%d].visual.id         = %X",  Scr.screen, Scr.asv->visual_info.visualid );
                display_progress( True, "    screen[%d].visual.id         = %X",  Scr.screen, Scr.asv->visual_info.visualid );
                show_progress( "\t screen[%d].visual.class      = %d",  Scr.screen, Scr.asv->visual_info.class );
                display_progress( True, "    screen[%d].visual.class      = %d",  Scr.screen, Scr.asv->visual_info.class );
                show_progress( "\t screen[%d].visual.red_mask   = 0x%8.8lX", Scr.screen, Scr.asv->visual_info.red_mask   );
                show_progress( "\t screen[%d].visual.green_mask = 0x%8.8lX", Scr.screen, Scr.asv->visual_info.green_mask );
                show_progress( "\t screen[%d].visual.blue_mask  = 0x%8.8lX", Scr.screen, Scr.asv->visual_info.blue_mask  );
                show_progress( "\t screen[%d].rdisplay_string = \"%s\"", Scr.screen, Scr.rdisplay_string );
                show_progress( "\t screen[%d].display_string = \"%s\"", Scr.screen, Scr.display_string );
                display_progress( True, "    screen[%d].display_string = \"%s\"", Scr.screen, Scr.display_string );
            }
        }
    }

   /* make sure we're on the right desk, and the _WIN_DESK property is set */
    Scr.CurrentDesk = INVALID_DESK ;
    if( get_flags( Scr.wmprops->set_props, WMC_ASDesks )  )
	{
		start_desk = Scr.wmprops->as_current_desk ;
    }else if( get_flags( Scr.wmprops->set_props, WMC_DesktopCurrent )  )
    {
        int curr = Scr.wmprops->desktop_current ;
        start_desk = curr;
        if( get_flags( Scr.wmprops->set_props, WMC_DesktopViewport ) &&
            curr < Scr.wmprops->desktop_viewports_num )
        {
            /* we have to do that prior to capturing any window so that they'll get in
             * correct position and will not end up outside of the screen */
            start_viewport_x = Scr.wmprops->desktop_viewport[curr<<1] ;
			start_viewport_y = Scr.wmprops->desktop_viewport[(curr<<1)+1] ;
        }
    }
    if( get_flags( Scr.wmprops->set_props, WMC_ASViewport )  )
	{
		start_viewport_x = Scr.wmprops->as_current_vx ;
		start_viewport_y = Scr.wmprops->as_current_vy ;
	}
	/* temporarily setting up desktop 0 */
	ChangeDesks(0);

    /* Load config ... */
    /* read config file, set up menus, colors, fonts */
    LoadASConfig (0, PARSE_EVERYTHING);

    /* Reparent all the windows and setup pan frames : */
    XSync (dpy, 0);
   /***********************************************************/
#ifndef DONT_GRAB_SERVER                    /* grabbed   !!!!!*/
	grab_server();                		/* grabbed   !!!!!*/
#endif										/* grabbed   !!!!!*/
    init_screen_panframes(ASDefaultScr);            /* grabbed   !!!!!*/
    display_progress( True, "Capturing all windows ..." );
    CaptureAllWindows (ASDefaultScr);               /* grabbed   !!!!!*/
    display_progress( False, "Done." );
    check_screen_panframes(ASDefaultScr);           /* grabbed   !!!!!*/
    ASSync( False );
#ifndef DONT_GRAB_SERVER                    /* grabbed   !!!!!*/
	ungrab_server();					/* UnGrabbed !!!!!*/
#endif										/* UnGrabbed !!!!!*/
	/**********************************************************/
    XDefineCursor (dpy, Scr.Root, Scr.Feel.cursors[ASCUR_Default]);

    display_progress( True, "Seting initial viewport to %+d%+d ...", Scr.wmprops->as_current_vx, Scr.wmprops->as_current_vy );

    SetupFunctionHandlers();
    display_progress( True, "Processing all pending events ..." );
    ConfigureNotifyLoop();
    display_progress( True, "All done." );
    remove_desktop_cover();

	if( !get_flags(AfterStepStartupFlags, ASSF_BypassAutoexec))
    	DoAutoexec(get_flags( AfterStepState, ASS_Restarting));
	
	/* once all the windows are swallowed and placed in its proper desks - we cas restore proper
	   desktop/viewport : */
	clear_flags( AfterStepState, ASS_SuppressDeskBack );
	ChangeDeskAndViewport ( start_desk, start_viewport_x, start_viewport_y, False);

    /* all system Go! we are completely Operational! */
    set_flags( AfterStepState, ASS_NormalOperation);

#if (defined(LOCAL_DEBUG)||defined(DEBUG)) && defined(DEBUG_ALLOCS)
    LOCAL_DEBUG_OUT( "printing memory%s","");
    spool_unfreed_mem( "afterstep.allocs.startup", NULL );
#endif
    LOCAL_DEBUG_OUT( "entering main loop%s","");

    HandleEvents ();
	return (0);
}
Example #9
0
/***********************************************************************
 * our signal handlers :
 ************************************************************************/
void
IgnoreSignal (int sig)
{
	if (signal (sig, SIG_IGN) != SIG_IGN)
		signal (sig, SigDone);
}
Example #10
0
int main(int argc, char **argv)
{
	int force = 0, lsock, csock, one = 0, jeden = 1, local_port;
	int detach = 1, sa_len, conn_limit = 0, optc;
	char *username = NULL, *bind_host = NULL;
	struct sockaddr *sa;
	struct sockaddr_in laddr, caddr;
	struct sockaddr_in6 laddr6;
	unsigned int caddrlen = sizeof(caddr);
	struct passwd *pw = NULL;
	
	while ((optc = getopt(argc, argv, "1dv46fHs:l:I:i:hu:m:L:A:p:")) != -1) {
		switch (optc) {
			case '1':
				one = 1;
				break;
			case 'd':
				detach = 0;
				break;
			case 'v':
				verbose = 1;
				break;
			case '4':
				break;
			case '6':
				remote_hint = AF_INET;
				local_hint = AF_INET6;
				break;
			case 's':
				source_host = xstrdup(optarg);
				break;
			case 'l':
				bind_host = xstrdup(optarg);
				break;
			case 'r':
				force = 1;
				break;
			case 'i':
				ircpass = xstrdup(optarg);
				clear_argv(argv[optind - 1]);
				break;
			case 'I':
				ircsendpass = xstrdup(optarg);
				clear_argv(argv[optind - 1]);
				break;
			case 'h':
				hexdump = 1;
				break;
			case 'u':
				username = xstrdup(optarg);
				break;
			case 'm':
				map_file = xstrdup(optarg);
				break;
			case 'L':
				conn_limit = atoi(optarg);
				break;
			case 'p':
				pid_file = xstrdup(optarg);
				break;
			case 'H':
				hint_optional = 1;
				break;
			default:
				return 1;
		}
	}

	if (hexdump)
		verbose = 1;

	if (verbose)
		detach = 0;
	
	if (detach)
		verbose = 0;

	if (argc - optind < 2) {
		usage(argv[0]);
		exit(1);
	}

	if (username && !(pw = getpwnam(username))) {
		fprintf(stderr, "%s: unknown user %s\n", argv[0], username);
		exit(1);
	}
  
	if (map_file)
		map_read();
  
	local_port = atoi(argv[optind++]);
	remote_host = argv[optind++];
	remote_port = (argc == optind) ? local_port : atoi(argv[optind]);

	debug("resolving %s\n", remote_host);

	if (!(sa = resolve_host(remote_host, remote_hint)) && !force) {
		fprintf(stderr, "%s: unable to resolve host %s\n", argv[0], remote_host);
		exit(1);
	}

	free(sa);
	sa = NULL;

	if (bind_host) {
		debug("resolving %s\n", bind_host);

		if (!(sa = resolve_host(bind_host, local_hint))) {
			fprintf(stderr, "%s: unable to resolve host %s\n", argv[0], remote_host);
			exit(1);
		}
	}
 
	debug("local: %s,%d; ", (bind_host) ? bind_host : "default", local_port);
	debug("remote: %s,%d; ", remote_host, remote_port);

	if (map_file)
		debug("source: mapped\n");
	else
		debug("source: %s\n", (source_host) ? source_host : "default");

	if (local_hint == AF_INET) {
		lsock = socket(PF_INET, SOCK_STREAM, 0);

		memset(&laddr, 0, (sa_len = sizeof(laddr)));
		laddr.sin_family = AF_INET;
		laddr.sin_port = htons(local_port);
		
		if (sa) {
			memcpy(&laddr.sin_addr, &((struct sockaddr_in*) sa)->sin_addr, sizeof(struct in_addr));
			free(sa);
		}
		
		sa = (struct sockaddr*) &laddr;
	} else {
		lsock = socket(PF_INET6, SOCK_STREAM, 0);
		
		memset(&laddr6, 0, (sa_len = sizeof(laddr6)));
		laddr6.sin6_family = AF_INET6;
		laddr6.sin6_port = htons(local_port);
		
		if (sa) {
			memcpy(&laddr6.sin6_addr, &((struct sockaddr_in6*) sa)->sin6_addr, sizeof(struct in6_addr));
			free(sa);
		}

		sa = (struct sockaddr*) &laddr6;
	}

	if (setsockopt(lsock, SOL_SOCKET, SO_REUSEADDR, &jeden, sizeof(jeden)) == -1) {
		perror("setsockopt");
		exit(1);
	}
  
	if (bind(lsock, sa, sa_len)) {
		perror("bind");
		exit(1);
	}    
  
	if (listen(lsock, 100)) {
		perror("listen");
		exit(1);
	}

	if (detach) {
		int i, ret;

		signal(SIGHUP, sighup);
		
		for (i = 0; i < 3; i++)
			close(i);

		ret = fork();
		
		if (ret == -1) {
			perror("fork");
			exit(1);
		}

		if (ret)
			exit(0);
	}

	if (pid_file) {
		FILE *f = fopen(pid_file, "w");

		if (!f)
			debug("warning: cannot write to pidfile (%s)\n", strerror(errno));
		else {
			fprintf(f, "%d", getpid());
			fclose(f);
		}
	}

	if (username && ((setgid(pw->pw_gid) == -1) || (setuid(pw->pw_uid) == -1))) {
		perror("setuid/setgid");
		exit(1);
	}

	setsid();
	signal(SIGCHLD, sigchld);
	signal(SIGTERM, sigterm);
	signal(SIGINT, sigterm);
	signal(SIGHUP, sighup);
    
	for (;;) {  
		int ret;
		fd_set rds;

		FD_ZERO(&rds);
		FD_SET(lsock, &rds);

		if (select(lsock + 1, &rds, NULL, NULL, NULL) == -1) {
			if (errno == EINTR)
				continue;

			perror("select");
			break;
		}

		if ((csock = accept(lsock, (struct sockaddr*) &caddr, &caddrlen)) == -1) {
			perror("accept");
			break;
		}

		inet_ntop(caddr.sin_family, (caddr.sin_family == AF_INET) ?
			&caddr.sin_addr :
			(void*) &(((struct sockaddr_in6*)&caddr)->sin6_addr),
			remote, sizeof(remote));

		debug("<%d> connection from %s,%d", csock, remote, ntohs(caddr.sin_port));

		if (conn_limit && (conn_count >= conn_limit)) {
			debug(" -- rejected due to limit.\n");
			shutdown(csock, 2);
			close(csock);
			continue;
		}
		
		if (conn_limit) {
			conn_count++;
			debug(" (no. %d)", conn_count);
		}
		
		fflush(stdout);
    
		if ((ret = fork()) == -1) {
			debug(" -- fork() failed.\n");
			shutdown(csock, 2);
			close(csock);
			continue;
		}
    
		if (!ret) {
			signal(SIGHUP, SIG_IGN);
			close(lsock);
			debug("\n");
			make_tunnel(csock, remote);
			debug("<%d> connection closed\n", csock);
			exit(0);
		} 

		close(csock);
    
		if (one) {
			shutdown(lsock, 2);
			close(lsock);
			exit(0);
		}

	}

	close(lsock);
  
	exit(1);
}
Example #11
0
int main(int argc, char *argv[])
{
	int interactive;
	int warning_displayed = 0;
	int c;
	int daemonize = 0;
	const char *global = NULL;

	if (os_program_init())
		return -1;

	for (;;) {
		c = getopt(argc, argv, "a:Bg:hi:p:P:v");
		if (c < 0)
			break;
		switch (c) {
		case 'a':
			action_file = optarg;
			break;
		case 'B':
			daemonize = 1;
			break;
		case 'g':
			global = optarg;
			break;
		case 'h':
			usage();
			return 0;
		case 'v':
			printf("%s\n", wpa_cli_version);
			return 0;
		case 'i':
			ctrl_ifname = strdup(optarg);
			break;
		case 'p':
			ctrl_iface_dir = optarg;
			break;
		case 'P':
			pid_file = optarg;
			break;
		default:
			usage();
			return -1;
		}
	}

	interactive = (argc == optind) && (action_file == NULL);

	if (interactive)
		printf("%s\n\n%s\n\n", wpa_cli_version, wpa_cli_license);

	if (global) {
		ctrl_conn = wpa_ctrl_open(global);
		if (ctrl_conn == NULL) {
			perror("Failed to connect to wpa_supplicant - "
			       "wpa_ctrl_open");
			return -1;
		}
	}

	for (; !global;) {
#ifndef CONFIG_CTRL_IFACE_UDP
		if (ctrl_ifname == NULL) {
			struct dirent *dent;
			DIR *dir = opendir(ctrl_iface_dir);
			if (dir) {
				while ((dent = readdir(dir))) {
#ifdef _DIRENT_HAVE_D_TYPE
					/* Skip the file if it is not a socket.
					 * Also accept DT_UNKNOWN (0) in case
					 * the C library or underlying file
					 * system does not support d_type. */
					if (dent->d_type != DT_SOCK &&
					    dent->d_type != DT_UNKNOWN)
						continue;
#endif /* _DIRENT_HAVE_D_TYPE */
					if (strcmp(dent->d_name, ".") == 0 ||
					    strcmp(dent->d_name, "..") == 0)
						continue;
					printf("Selected interface '%s'\n",
					       dent->d_name);
					ctrl_ifname = strdup(dent->d_name);
					break;
				}
				closedir(dir);
			}
		}
#endif /* CONFIG_CTRL_IFACE_UDP */
		ctrl_conn = wpa_cli_open_connection(ctrl_ifname);
		if (ctrl_conn) {
			if (warning_displayed)
				printf("Connection established.\n");
			break;
		}

		if (!interactive) {
			perror("Failed to connect to wpa_supplicant - "
			       "wpa_ctrl_open");
			return -1;
		}

		if (!warning_displayed) {
			printf("Could not connect to wpa_supplicant - "
			       "re-trying\n");
			warning_displayed = 1;
		}
		os_sleep(1, 0);
		continue;
	}

#ifndef _WIN32_WCE
	signal(SIGINT, wpa_cli_terminate);
	signal(SIGTERM, wpa_cli_terminate);
#endif /* _WIN32_WCE */
#ifndef CONFIG_NATIVE_WINDOWS
	signal(SIGALRM, wpa_cli_alarm);
#endif /* CONFIG_NATIVE_WINDOWS */

	if (interactive || action_file) {
		if (wpa_ctrl_attach(ctrl_conn) == 0) {
			wpa_cli_attached = 1;
		} else {
			printf("Warning: Failed to attach to "
			       "wpa_supplicant.\n");
			if (!interactive)
				return -1;
		}
	}

	if (daemonize && os_daemonize(pid_file))
		return -1;

	if (interactive)
		wpa_cli_interactive();
	else if (action_file)
		wpa_cli_action(ctrl_conn);
	else
		wpa_request(ctrl_conn, argc - optind, &argv[optind]);

	free(ctrl_ifname);
	wpa_cli_cleanup();

	return 0;
}
Example #12
0
void *
xmalloc_large_ext (size_t sz)
{
#if !defined(__MTA__)&&defined(USE_MMAP_LARGE_EXT)
	char extname[4096+1];
	char *tmppath;
	void *out;
	int fd, which;
	
	if (getenv ("TMPDIR"))
		tmppath = getenv ("TMPDIR");
	else if (getenv ("TEMPDIR"))
		tmppath = getenv ("TEMPDIR");
	else
		tmppath = "/tmp";
	
	sprintf (extname, "%s/graph500-ext-XXXXXX", tmppath);
	
	which = n_large_alloc++;
	if (n_large_alloc > MAX_LARGE) {
		fprintf (stderr, "Out of large allocations.\n");
		abort ();
	}
	large_alloc[which].p = 0;
	large_alloc[which].fd = -1;
	
	fd = mkstemp (extname);
	if (fd < 0) {
		perror ("xmalloc_large_ext failed to make a file");
		abort ();
	}
	if (unlink (extname)) {
		perror ("UNLINK FAILED!");
		goto errout;
	}
	
#if _XOPEN_SOURCE >= 500
	if (pwrite (fd, &fd, sizeof (fd), sz - sizeof(fd)) != sizeof (fd)) {
		perror ("resizing pwrite failed");
		goto errout;
	}
#else
	if (lseek (fd, sz - sizeof(fd), SEEK_SET) < 0) {
		perror ("lseek failed");
		goto errout;
	}
	if (write (fd, &fd, sizeof(fd)) != sizeof (fd)) {
		perror ("resizing write failed");
		goto errout;
	}
#endif
	fcntl (fd, F_SETFD, O_ASYNC);
	
	out = mmap (NULL, sz, PROT_READ|PROT_WRITE,
				MAP_SHARED|MAP_POPULATE|MAP_NOSYNC, fd, 0);
	if (MAP_FAILED == out || !out) {
		perror ("mmap ext failed");
		goto errout;
	}
	
	if (!installed_handler) {
		installed_handler = 1;
		if (atexit (exit_handler)) {
			perror ("failed to install exit handler");
			goto errout;
		}
		
		old_abort_handler = signal (SIGABRT, abort_handler);
		if (SIG_ERR == old_abort_handler) {
			perror ("failed to install cleanup handler");
			goto errout;
		}
	}
	
	large_alloc[which].p = out;
	large_alloc[which].sz = sz;
	large_alloc[which].fd = fd;
	
	return out;
	
errout:
	if (fd >= 0) close (fd);
	abort ();
#else
	return xmalloc_large (sz);
#endif
}
/*
 * ##########################
 * Main Function
 * ##########################
 */
int main(int argc, char *argv[])
{
	/* program setup variable */
	struct mosquitto *mosq = NULL;
	struct mqtt_userdata *ud = NULL;
	bool clean_session = true;
	bool debug = false;
	char buf[MQTT_BUFSIZE];
	char err[MQTT_ERR_BUFSIZE];
	/* client id */
	char id[MQTT_ID_LEN];
	char id_prefix[MQTT_ID_LEN];
	char hostname[MQTT_HOSTNAME_BUFSIZE];
	/* broker variable */
	char host[MQTT_IP_LEN] = "127.0.0.1";
	int port = 1883;
	int keepalive = 3600;
	/* will information */
	char *will_topic = NULL;
	long will_payloadlen = 0;
	char *will_payload = NULL;
	int will_qos = 0;
	bool will_retain = false;
	/* temp variable */
	int i;
	int rc;

	/* initialized program and user data structure */
	ud = malloc(sizeof(struct mqtt_userdata));
	memset(ud, 0, sizeof(struct mqtt_userdata));
	memset(id, '\0', sizeof(id));
	memset(id_prefix, '\0', sizeof(id_prefix));
	ud->topic_qos = 2;

	/* get option */
	for(i=1; i<argc; i++){
		if(!strcmp(argv[i], "-p") || !strcmp(argv[i], "--port")){
			if(i==argc-1){
				fprintf(stderr, "Error: -p argument given but no port specified.\n\n");
				mqtt_print_usage();
				return 1;
			}else{
				port = atoi(argv[i+1]);
				if(port<1 || port>65535){
					fprintf(stderr, "Error: Invalid port given: %d\n", port);
					mqtt_print_usage();
					return 1;
				}
			}
			i++;
		}else if(!strcmp(argv[i], "-c") || !strcmp(argv[i], "--disable-clean-session")){
			clean_session = false;
		}else if(!strcmp(argv[i], "-d") || !strcmp(argv[i], "--debug")){
			debug = true;
		}else if(!strcmp(argv[i], "--help")){
			mqtt_print_usage();
			return 0;
		}else if(!strcmp(argv[i], "-h") || !strcmp(argv[i], "--host")){
			if(i==argc-1){
				fprintf(stderr, "Error: -h argument given but no host specified.\n\n");
				mqtt_print_usage();
				return 1;
			}else{
				if (strlen(argv[i+1]) >= MQTT_IP_LEN) {
					fprintf(stderr, "Error: max length of ip is %d.\n\n", MQTT_IP_LEN);
					mqtt_print_usage();
				} else {
					memset(host, '\0', sizeof(host));
					strcpy(host, argv[i+1]);
				}
			}
			i++;
		}else if(!strcmp(argv[i], "-i") || !strcmp(argv[i], "--id")){
			if(strlen(id_prefix) != 0){
				fprintf(stderr, "Error: -i and -I argument cannot be used together.\n\n");
				mqtt_print_usage();
				return 1;
			}
			if(i==argc-1){
				fprintf(stderr, "Error: -i argument given but no id specified.\n\n");
				mqtt_print_usage();
				return 1;
			}else{
				if (strlen(argv[i+1]) >= MOSQ_MQTT_ID_MAX_LENGTH) {
					fprintf(stderr, "Error: max length of client id is %d.\n\n", MOSQ_MQTT_ID_MAX_LENGTH);
					mqtt_print_usage();
				} else {
					strcpy(id, argv[i+1]);
				}
			}
			i++;
		}else if(!strcmp(argv[i], "-I") || !strcmp(argv[i], "--id-prefix")){
			if(strlen(id) != 0){
				fprintf(stderr, "Error: -i and -I argument cannot be used together.\n\n");
				mqtt_print_usage();
				return 1;
			}
			if(i==argc-1){
				fprintf(stderr, "Error: -I argument given but no id prefix specified.\n\n");
				mqtt_print_usage();
				return 1;
			}else{
				if (strlen(argv[i+1]) >= MOSQ_MQTT_ID_MAX_LENGTH) {
					fprintf(stderr, "Error: max length of client id is %d.\n\n", MOSQ_MQTT_ID_MAX_LENGTH);
					mqtt_print_usage();
				} else {
					strcpy(id_prefix, argv[i+1]);
				}
			}
			i++;
		}else if(!strcmp(argv[i], "-k") || !strcmp(argv[i], "--keepalive")){
			if(i==argc-1){
				fprintf(stderr, "Error: -k argument given but no keepalive specified.\n\n");
				mqtt_print_usage();
				return 1;
			}else{
				keepalive = atoi(argv[i+1]);
				if(keepalive>65535){
					fprintf(stderr, "Error: Invalid keepalive given: %d\n", keepalive);
					mqtt_print_usage();
					return 1;
				}
			}
			i++;
		}else if(!strcmp(argv[i], "-q") || !strcmp(argv[i], "--qos")){
			if(i==argc-1){
				fprintf(stderr, "Error: -q argument given but no QoS specified.\n\n");
				mqtt_print_usage();
				return 1;
			}else{
				ud->topic_qos = atoi(argv[i+1]);
				if(ud->topic_qos<0 || ud->topic_qos>2){
					fprintf(stderr, "Error: Invalid QoS given: %d\n", ud->topic_qos);
					mqtt_print_usage();
					return 1;
				}
			}
			i++;
		}else if(!strcmp(argv[i], "--quiet")){
			ud->quiet = true;
		}else if(!strcmp(argv[i], "-R")){
			ud->no_retain = true;
		}else if(!strcmp(argv[i], "-t") || !strcmp(argv[i], "--topic")){
			if(i==argc-1){
				fprintf(stderr, "Error: -t argument given but no topic specified.\n\n");
				mqtt_print_usage();
				return 1;
			}else{
				ud->topic_count++;
				ud->topics = realloc(ud->topics, ud->topic_count*sizeof(char *));
				ud->topics[ud->topic_count-1] = argv[i+1];
			}
			i++;
		}else if(!strcmp(argv[i], "-u") || !strcmp(argv[i], "--username")){
			if(i==argc-1){
				fprintf(stderr, "Error: -u argument given but no username specified.\n\n");
				mqtt_print_usage();
				return 1;
			}else{
				ud->username = argv[i+1];
			}
			i++;
		}else if(!strcmp(argv[i], "-v") || !strcmp(argv[i], "--verbose")){
			ud->verbose = 1;
		}else if(!strcmp(argv[i], "-P") || !strcmp(argv[i], "--pw")){
			if(i==argc-1){
				fprintf(stderr, "Error: -P argument given but no password specified.\n\n");
				mqtt_print_usage();
				return 1;
			}else{
				ud->password = argv[i+1];
			}
			i++;
		}else if(!strcmp(argv[i], "--will-payload")){
			if(i==argc-1){
				fprintf(stderr, "Error: --will-payload argument given but no will payload specified.\n\n");
				mqtt_print_usage();
				return 1;
			}else{
				will_payload = argv[i+1];
				will_payloadlen = strlen(will_payload);
			}
			i++;
		}else if(!strcmp(argv[i], "--will-qos")){
			if(i==argc-1){
				fprintf(stderr, "Error: --will-qos argument given but no will QoS specified.\n\n");
				mqtt_print_usage();
				return 1;
			}else{
				will_qos = atoi(argv[i+1]);
				if(will_qos < 0 || will_qos > 2){
					fprintf(stderr, "Error: Invalid will QoS %d.\n\n", will_qos);
					return 1;
				}
			}
			i++;
		}else if(!strcmp(argv[i], "--will-retain")){
			will_retain = true;
		}else if(!strcmp(argv[i], "--will-topic")){
			if(i==argc-1){
				fprintf(stderr, "Error: --will-topic argument given but no will topic specified.\n\n");
				mqtt_print_usage();
				return 1;
			}else{
				will_topic = argv[i+1];
			}
			i++;
		}else{
			fprintf(stderr, "Error: Unknown option '%s'.\n",argv[i]);
			mqtt_print_usage();
			return 1;
		}
	}

	/* verify necessary variable */
	if(clean_session == false && ((strlen(id_prefix) != 0) || (strlen(id) == 0))){
		if(!ud->quiet) fprintf(stderr, "Error: You must provide a client id if you are using the -c option.\n");
		return 1;
	}
	if(ud->topic_count == 0){
		fprintf(stderr, "Error: You must specify a topic to subscribe to.\n");
		mqtt_print_usage();
		return 1;
	}
	if(will_payload && !will_topic){
		fprintf(stderr, "Error: Will payload given, but no will topic given.\n");
		mqtt_print_usage();
		return 1;
	}
	if(will_retain && !will_topic){
		fprintf(stderr, "Error: Will retain given, but no will topic given.\n");
		mqtt_print_usage();
		return 1;
	}
	if(ud->password && !ud->username){
		if(!ud->quiet) fprintf(stderr, "Warning: Not using password since username not set.\n");
	}

	/* setup signal handler */
	signal(SIGINT, mqtt_signal_handler);
	signal(SIGTERM, mqtt_signal_handler);

	/* init mosquitto library */
	mosquitto_lib_init();

	/* setup client id */
	if(strlen(id_prefix) != 0){
		snprintf(id, sizeof(id), "%s%d", id_prefix, getpid());
	}else if(strlen(id) == 0){
		memset(hostname, '\0', sizeof(hostname));
		gethostname(hostname, sizeof(hostname));
		snprintf(id, sizeof(id), "mosqsub/%d-%s", getpid(), hostname);
	}
	if(strlen(id) > MOSQ_MQTT_ID_MAX_LENGTH){
		/* Enforce maximum client id length of 23 characters */
		id[MOSQ_MQTT_ID_MAX_LENGTH] = '\0';
	}

	/* start mosquitto */
	mosq = mosquitto_new(id, clean_session, ud);
	if(!mosq){
		if(!ud->quiet) fprintf(stderr, "Error: %s\n", strerror(errno));
		mosquitto_lib_cleanup();
		return 1;
	}

	/* setup mosquitto */
	if(debug){
		mosquitto_log_callback_set(mosq, mqtt_log_callback);
	}
	if(will_topic && mosquitto_will_set(mosq, will_topic, will_payloadlen, will_payload, will_qos, will_retain)){
		if(!ud->quiet) fprintf(stderr, "Error: Problem setting will.\n");
		mosquitto_lib_cleanup();
		return 1;
	}
	if(ud->username && mosquitto_username_pw_set(mosq, ud->username, ud->password)){
		if(!ud->quiet) fprintf(stderr, "Error: Problem setting username and password.\n");
		mosquitto_lib_cleanup();
		return 1;
	}
	mosquitto_connect_callback_set(mosq, mqtt_connect_callback);
	mosquitto_message_callback_set(mosq, mqtt_message_callback);
	if(debug){
		mosquitto_subscribe_callback_set(mosq, mqtt_subscribe_callback);
	}

	/* connect mosquitto */
	rc = mosquitto_connect(mosq, host, port, keepalive);
	if(rc){
		if(!ud->quiet){
			if(rc == MOSQ_ERR_ERRNO){
#ifndef WIN32
				strerror_r(errno, err, sizeof(err));
#else
				FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, errno, 0, (LPTSTR)&err, sizeof(err), NULL);
#endif
				fprintf(stderr, "Error: %s\n", err);
			}else{
				fprintf(stderr, "Unable to connect (%d: %s).\n", rc, mosquitto_strerror(rc));
			}
		}
		mosquitto_lib_cleanup();
		return rc;
	}

	mosquitto_loop_start(mosq);

	/*
	 * loop mosquitto,
	 * it use select() to call back the callback-function which defined before.
	 */
	do{
		if (fgets(buf, sizeof(buf), stdin)) {
			buf[strlen(buf)-1] = '\0';
			rc = mosquitto_publish(mosq, &ud->mid_sent, "simon", strlen(buf), buf, 0, 0);
			if (rc) {
				if (!ud->quiet) fprintf(stderr, "Error: Publish returned %d, disconnecting.\n", rc);
				mosquitto_disconnect(mosq);
			}
		}
	} while (rc == MOSQ_ERR_SUCCESS);

	mosquitto_loop_stop(mosq, false);

	/* free mosquitto */
	mosquitto_destroy(mosq);
	mosquitto_lib_cleanup();
	mqtt_userdata_free(ud);

	return 0;
}
Example #14
0
void posix_death_signal(int signum)
{
    memento();
    signal(signum, SIG_DFL);
    exit(3);
}
Example #15
0
int main(int argc, char *argv[])
{

    /* Make sure we received two arguments,
       a hostname and a port number. */
    if (argc < 2) {
	printf("Simple TCP/IP uptime server.\n");
	printf("Usage: %s <port>\n", argv[0]);
	return 1;
    }

    port = atoi(argv[1]);

    /* Create the listener socket. This socket will queue
       incoming connections. */
    listener = socket(PF_INET, SOCK_STREAM, IPPROTO_IP);
    if (listener < 0) {
	printf("Unable to create a listener socket: %s\n",
	       strerror(errno));
	return 1;
    }

    /* Now bind the listener to a local address. This uses
       the same sockaddr_in structure as connect. */
    sa_len = sizeof(sa);
    memset(&sa, 0, sa_len);
    sa.sin_family = AF_INET;
    sa.sin_port = htons(port);
    sa.sin_addr.s_addr = htonl(INADDR_ANY); /* Listen on all interfaces. */

    if (bind(listener, &sa, sa_len) < 0) {
	printf("Unable to bind to port %i: %s\n",
	       port,
	       strerror(errno));
	return 1;
    }

    /* Let the networking system know we're accepting
       connections on this socket. Ask for a connection
       queue of five clients. (If more than five clients
       try to connect before we call accept, some will
       be denied.) */
    if (listen(listener, 5) < 0) {
	printf("Unable to listen: %s\n",
	       strerror(errno));
	return 1;
    }

    /* Ready! Now accept connections until the user presses
       Control-C. */
    signal(SIGINT, signal_handler);

    for (;;) {
	char sendbuf[1024];
	int sent, length;
	FILE *uptime;

	client = accept(listener, &sa, &sa_len);
	if (client < 0) {
	    printf("Unable to accept: %s\n",
		   strerror(errno));
	    close(listener);
	    return 1;
	}

	/* We now have a live client. Print information
	   about it and then send something over the wire. */
	inet_ntop(AF_INET, &sa.sin_addr, dotted_ip, 15);
	printf("Received connection from %s.\n", dotted_ip);

	/* Use popen to retrieve the output of the
	   uptime command. This is a bit of a hack, but
	   it's portable and it works fairly well.
	   popen opens a pipe to a program (that is, it
	   executes the program and redirects its I/O
	   to a file handle). */
	uptime = popen("/usr/bin/uptime", "r");
	if (uptime == NULL) {
	    strcpy(sendbuf, "Unable to read system's uptime.\n");
	} else {
	    sendbuf[0] = '\0';
	    fgets(sendbuf, 1023, uptime);
	    pclose(uptime);
	}
		
	/* Figure out how much data we need to send. */
	length = strlen(sendbuf);
	sent = 0;

	/* Repeatedly call write until the entire
	   buffer is sent. */
	while (sent < length) {
	    int amt;

	    amt = write(client, sendbuf+sent, length-sent);

	    if (amt <= 0) {
				/* Zero-byte writes are OK if they
				   are caused by signals (EINTR).
				   Otherwise they mean the socket
				   has been closed. */
		if (errno == EINTR)
		    continue;
		else {
		    printf("Send error: %s\n",
			   strerror(errno));
		    break;
		}
	    }

	    /* Update our position by the number of
	       bytes that were sent. */
	    sent += amt;
	}

	close(client);
    }

    return 0;
}
Example #16
0
void handle_sigint(int signum){
  logd("Caught sigint %i\n", signum);
  should_close = true;
  signal(SIGINT, NULL); // next time just quit.
}
Example #17
0
int main(int argc, char **argv)
{
	//Register signal and signal handler
	signal(SIGINT, signal_callback_handler);
	
	//Init UDP with callbacks and pointer to run status
	initUDP( &UDP_Command_Handler, &UDP_Control_Handler, &Running );
	
	print("Eddie starting...\r\n");

	initIdentity();
	
	double EncoderPos[2] = {0};
	
	initEncoders( 183, 46, 45, 44 );
	print("Encoders activated.\r\n");

	imuinit();
	print("IMU Started.\r\n");

	float kalmanAngle;
	InitKalman();
	
#ifndef DISABLE_MOTORS
	print( "Starting motor driver (and resetting wireless) please be patient..\r\n" );
	if ( motor_driver_enable() < 1 )
		{
			print("Startup Failed; Error starting motor driver.\r\n");
			motor_driver_disable();
			return -1;
		}
	print("Motor Driver Started.\r\n");
#endif
	
	print("Eddie is starting the UDP network thread..\r\n");
	pthread_create( &udplistenerThread, NULL, &udplistener_Thread, NULL );
	
	print( "Eddie is Starting PID controllers\r\n" );
	/*Set default PID values and init pitchPID controllers*/
	pidP_P_GAIN = PIDP_P_GAIN;	pidP_I_GAIN = PIDP_I_GAIN;	pidP_D_GAIN = PIDP_D_GAIN;	pidP_I_LIMIT = PIDP_I_LIMIT; pidP_EMA_SAMPLES = PIDP_EMA_SAMPLES;
	PIDinit( &pitchPID[0], &pidP_P_GAIN, &pidP_I_GAIN, &pidP_D_GAIN, &pidP_I_LIMIT, &pidP_EMA_SAMPLES );
	PIDinit( &pitchPID[1], &pidP_P_GAIN, &pidP_I_GAIN, &pidP_D_GAIN, &pidP_I_LIMIT, &pidP_EMA_SAMPLES );
	
	/*Set default values and init speedPID controllers*/
	pidS_P_GAIN = PIDS_P_GAIN;	pidS_I_GAIN = PIDS_I_GAIN;	pidS_D_GAIN = PIDS_D_GAIN;	pidS_I_LIMIT = PIDS_I_LIMIT; pidS_EMA_SAMPLES = PIDS_EMA_SAMPLES;
	PIDinit( &speedPID[0], &pidS_P_GAIN, &pidS_I_GAIN, &pidS_D_GAIN, &pidS_I_LIMIT, &pidS_EMA_SAMPLES );
	PIDinit( &speedPID[1], &pidS_P_GAIN, &pidS_I_GAIN, &pidS_D_GAIN, &pidS_I_LIMIT, &pidS_EMA_SAMPLES );
	
	//Get estimate of starting angle and specify complementary filter and kalman filter start angles
	getOrientation();
	kalmanAngle = filteredPitch = i2cPitch;
	setkalmanangle( filteredPitch );
	filteredRoll = i2cRoll;
	
	print( "Eddie startup complete. Hold me upright to begin\r\n" );
	
	double gy_scale = 0.01;
	last_PID_ms = last_gy_ms = current_milliseconds();
	
	while(Running)
	{
		GetEncoders( EncoderPos );
		
		if( fabs(GetEncoder()) > 2000 && !inRunAwayState )
		{
			print( "Help! I'm running and not moving.\r\n");
			ResetEncoders();
			inRunAwayState=1;
		}
		
		/*Read IMU and calculate rough angle estimates*/
		getOrientation();
		
		/*Calculate time since last IMU reading and determine gyro scale (dt)*/
		gy_scale = ( current_milliseconds() - last_gy_ms ) / 1000.0f;
	
		last_gy_ms = current_milliseconds();
		
		/*Complementary filters to smooth rough pitch and roll estimates*/
		filteredPitch = 0.995 * ( filteredPitch + ( gy * gy_scale ) ) + ( 0.005 * i2cPitch );
		filteredRoll = 0.98 * ( filteredRoll + ( gx * gy_scale ) ) + ( 0.02 * i2cRoll );

		/*Kalman filter for most accurate pitch estimates*/	
		kalmanAngle = -getkalmanangle(filteredPitch, gy, gy_scale /*dt*/);

		/* Monitor angles to determine if Eddie has fallen too far... or if Eddie has been returned upright*/
		if ( ( inRunAwayState || ( fabs( kalmanAngle ) > 50 || fabs( filteredRoll ) > 45 ) ) && !inFalloverState ) 
		{
#ifndef DISABLE_MOTORS
			motor_driver_standby(1);
#endif
			inFalloverState = 1;
			print( "Help! I've fallen over and I can't get up =)\r\n");
		} 
		else if ( fabs( kalmanAngle ) < 10 && inFalloverState && fabs( filteredRoll ) < 20 )
		{
			if ( ++inSteadyState == 100 )
			{
				inRunAwayState = 0;
				inSteadyState = 0;
#ifndef DISABLE_MOTORS
				motor_driver_standby(0);
#endif
				inFalloverState = 0;
				print( "Thank you!\r\n" );
			}
		}
		else
		{
			inSteadyState = 0;
		}

		if ( !inFalloverState )
		{
			/* Drive operations */
			smoothedDriveTrim = ( 0.99 * smoothedDriveTrim ) + ( 0.01 * driveTrim );
			if( smoothedDriveTrim != 0 ) 
			{
				EncoderAddPos(smoothedDriveTrim); //Alter encoder position to generate movement
			}
			
			/* Turn operations */
			if( turnTrim != 0  )
			{
				EncoderAddPos2( turnTrim, -turnTrim ); //Alter encoder positions to turn
			}
						
			double timenow = current_milliseconds();

			speedPIDoutput[0] = PIDUpdate( 0, EncoderPos[0], timenow - last_PID_ms, &speedPID[0] );//Wheel Speed PIDs
			speedPIDoutput[1] = PIDUpdate( 0, EncoderPos[1], timenow - last_PID_ms, &speedPID[1] );//Wheel Speed PIDs
			pitchPIDoutput[0] = PIDUpdate( speedPIDoutput[0], kalmanAngle, timenow - last_PID_ms, &pitchPID[0] );//Pitch Angle PIDs		
			pitchPIDoutput[1] = PIDUpdate( speedPIDoutput[1], kalmanAngle, timenow - last_PID_ms, &pitchPID[1] );//Pitch Angle PIDs
			
			last_PID_ms = timenow;
			
			//Limit PID output to +/-100 to match 100% motor throttle
			if ( pitchPIDoutput[0] > 100.0 )  pitchPIDoutput[0] = 100.0;
			if ( pitchPIDoutput[1] > 100.0 )  pitchPIDoutput[1] = 100.0;
			if ( pitchPIDoutput[0] < -100.0 ) pitchPIDoutput[0] = -100.0;
			if ( pitchPIDoutput[1] < -100.0 ) pitchPIDoutput[1] = -100.0;

		}
		else //We are inFalloverState
		{
			ResetEncoders();
			pitchPID[0].accumulatedError = 0;
			pitchPID[1].accumulatedError = 0;
			speedPID[0].accumulatedError = 0;
			speedPID[1].accumulatedError = 0;
			driveTrim = 0;
			turnTrim = 0;
		}
	
#ifndef DISABLE_MOTORS
		set_motor_speed_right( pitchPIDoutput[0] );
		set_motor_speed_left( pitchPIDoutput[1] );
#endif

		if ( (!inFalloverState || outputto == UDP) && StreamData )
		{			
			print( "PIDout: %0.2f,%0.2f\tcompPitch: %6.2f kalPitch: %6.2f\tPe: %0.3f\tIe: %0.3f\tDe: %0.3f\tPe: %0.3f\tIe: %0.3f\tDe: %0.3f\r\n",
				speedPIDoutput[0], 
				pitchPIDoutput[0], 
				filteredPitch, 
				kalmanAngle,
				pitchPID[0].error, 
				pitchPID[0].accumulatedError, 
				pitchPID[0].differentialError, 
				speedPID[0].error, 
				speedPID[0].accumulatedError, 
				speedPID[0].differentialError 
				);
		}

	} //--while(Running)
	
	print( "Eddie is cleaning up...\r\n" );
	
	CloseEncoder();
	
	pthread_join(udplistenerThread, NULL);
	print( "UDP Thread Joined..\r\n" );

#ifndef DISABLE_MOTORS
	motor_driver_disable();
	print( "Motor Driver Disabled..\r\n" );
#endif
	
	print( "Eddie cleanup complete. Good Bye!\r\n" );
	return 0;
}
Example #18
0
void
ipmi_start_daemon(struct ipmi_intf *intf)
{
	pid_t pid;
	int fd;
#ifdef SIGHUP
	sigset_t sighup;
#endif

#ifdef SIGHUP
	sigemptyset(&sighup);
	sigaddset(&sighup, SIGHUP);
	if (sigprocmask(SIG_UNBLOCK, &sighup, NULL) < 0)
		fprintf(stderr, "ERROR: could not unblock SIGHUP signal\n");
	signal(SIGHUP, SIG_IGN);
#endif
#ifdef SIGTTOU
	signal(SIGTTOU, SIG_IGN);
#endif
#ifdef SIGTTIN
	signal(SIGTTIN, SIG_IGN);
#endif
#ifdef SIGQUIT
	signal(SIGQUIT, SIG_IGN);
#endif
#ifdef SIGTSTP
	signal(SIGTSTP, SIG_IGN);
#endif

	pid = (pid_t) fork();
	if (pid < 0 || pid > 0)
		exit(0);

#if defined(SIGTSTP) && defined(TIOCNOTTY)
	if (setpgid(0, getpid()) == -1)
		exit(1);
	if ((fd = open(_PATH_TTY, O_RDWR)) >= 0) {
		ioctl(fd, TIOCNOTTY, NULL);
		close(fd);
	}
#else
	if (setpgid(0, 0) == -1)
		exit(1);
	pid = (pid_t) fork();
	if (pid < 0 || pid > 0)
		exit(0);
#endif

	chdir("/");
	umask(0);

	for (fd=0; fd<64; fd++) {
		if (fd != intf->fd)
			close(fd);
	}

	fd = open("/dev/null", O_RDWR);
	assert(0 == fd);
	dup(fd);
	dup(fd);
}
Example #19
0
File: mpg321.c Project: e3c/mpg321
int main(int argc, char *argv[])
{
    int fd = 0;
    char *currentfile, old_dir[PATH_MAX];
    playlist *pl = NULL;
    struct id3_file *id3struct = NULL;
    struct id3_tag *id3tag = NULL;

    buffer playbuf;
    
    struct mad_decoder decoder;

    old_dir[0] = '\0';

    playbuf.pl = pl = new_playlist();

    if (!pl)
    {
        fprintf(stderr, "malloc failed at startup!\n");
        exit(1);
    }

    options.volume = MAD_F_ONE;

    status = MPG321_PLAYING;
    
    /* Get the command line options */
    parse_options(argc, argv, pl);

    /* If there were no files and no playlist specified just print the usage */
    if (!playlist_file && optind == argc)
    {
        usage(argv[0]);
        exit(0);
    }

    if (playlist_file)
        load_playlist(pl, playlist_file);
    
    add_cmdline_files(pl, argv);

    if (shuffle_play)
        shuffle_files(pl);

    ao_initialize();

    check_default_play_device();
    
    if (!(options.opt & MPG321_REMOTE_PLAY))
    {
        handle_signals(-1); /* initialize signal handler */
     
        remote_input_buf[0] = '\0';
    }
    
    if (!(options.opt & MPG321_QUIET_PLAY)) 
        mpg123_boilerplate();
    
    if (options.opt & MPG321_REMOTE_PLAY)
    {
        printf ("@R MPG123\n");
    }
    
    /* Play the mpeg files or zip it! */
    while((currentfile = get_next_file(pl, &playbuf)))
    {
        if (quit_now) 
            break;
        
        signal(SIGINT, SIG_DFL);
        
        playbuf.buf = NULL;
        playbuf.fd = -1;
        playbuf.length = 0;
        playbuf.done = 0;
        playbuf.num_frames = 0;
        playbuf.max_frames = -1;
        strncpy(playbuf.filename,currentfile, PATH_MAX);
        playbuf.filename[PATH_MAX-1] = '\0';
        
        if (status == MPG321_PLAYING) 
            file_change = 1;

        mad_timer_reset(&playbuf.duration);
        
        mad_timer_reset(&current_time);

        if (!(options.opt & MPG321_QUIET_PLAY) && file_change)
        {
            id3struct = id3_file_open (currentfile, ID3_FILE_MODE_READONLY);

            if (id3struct)
            {
                id3tag = id3_file_tag (id3struct);
            
                if (id3tag)
                {
                    show_id3 (id3tag);
                }

                id3_file_close (id3struct);
            }
        }

        if (options.opt & MPG321_REMOTE_PLAY && file_change)
        {
            id3struct = id3_file_open (currentfile, ID3_FILE_MODE_READONLY);

            if (id3struct)
            {
                id3tag = id3_file_tag (id3struct);
            
                if (id3tag)
                {
                    if (!show_id3(id3tag))
                    {
                        /* This shouldn't be necessary, but it appears that
                           libid3tag doesn't necessarily know if there are no
                           id3 tags on a given mp3 */
                        char * basec = strdup(currentfile);
                        char * basen = basename(basec);
                        
                        char * dot = strrchr(basen, '.');
                        
                        if (dot)
                            *dot = '\0';
                        
                        printf("@I %s\n", basen);

                        free(basec);
                    }
                }
                
                else
                {
                    fprintf(stderr, "Allocation error");
                    exit(1);
                }

                id3_file_close (id3struct);
            }
            
            else
            {
                char * basec = strdup(currentfile);
                char * basen = basename(basec);
                
                char * dot = strrchr(basen, '.');
                
                if (dot)
                    *dot = '\0';
                
                printf("@I %s\n", basen);

                free(basec);
            }
        }

        /* Create the MPEG stream */
        /* Check if source is on the network */
        if((fd = raw_open(currentfile)) != 0 || (fd = http_open(currentfile)) != 0
            || (fd = ftp_open(currentfile)) != 0)
        {
            playbuf.fd = fd;
            playbuf.buf = malloc(BUF_SIZE);
            playbuf.length = BUF_SIZE;
            
            mad_decoder_init(&decoder, &playbuf, read_from_fd, read_header, /*filter*/0,
                            output, /*error*/0, /* message */ 0);
        }

        /* Check if we are to use stdin for input */
        else if(strcmp(currentfile, "-") == 0)
        {
            playbuf.fd = fileno(stdin);
            playbuf.buf = malloc(BUF_SIZE);
            playbuf.length = BUF_SIZE;

            mad_decoder_init(&decoder, &playbuf, read_from_fd, read_header, /*filter*/0,
                            output, /*error*/0, /* message */ 0);
        }
            
        /* currentfile is a local file (presumably.) mmap() it */
        else
        {
            struct stat stat;
            
            if((fd = open(currentfile, O_RDONLY)) == -1)
            {
                mpg321_error(currentfile);

                /* mpg123 stops immediately if it can't open a file */
                break;
            }
            
            if(fstat(fd, &stat) == -1)
            {
                close(fd);
                mpg321_error(currentfile);
                continue;
            }
            
            if (!S_ISREG(stat.st_mode))
            {
                close(fd);
                continue;
            }
            
            calc_length(currentfile, &playbuf);

            if ((options.maxframes != -1) && (options.maxframes <= playbuf.num_frames))
            { 
                playbuf.max_frames = options.maxframes;
            }
            
            playbuf.frames = malloc((playbuf.num_frames + 1) * sizeof(void*));
            playbuf.times = malloc((playbuf.num_frames + 1) * sizeof(mad_timer_t));
    
            if((playbuf.buf = mmap(0, playbuf.length, PROT_READ, MAP_SHARED, fd, 0))
                                == MAP_FAILED)
            {
                close(fd);
                mpg321_error(currentfile);
                continue;
            }
            
            close(fd);
            playbuf.frames[0] = playbuf.buf;
            
            mad_decoder_init(&decoder, &playbuf, read_from_mmap, read_header, /*filter*/0,
                            output, /*error*/0, /* message */ 0);
        }

        if(!(options.opt & MPG321_QUIET_PLAY))/*zip it!!!*/
        {
            /* Because dirname might modify the argument */
            char * dirc = strdup(currentfile);
            char * basec = strdup(currentfile);

            char * basen = basename(basec);
            char * dirn = dirname(dirc);
            
            /* make sure that the file has a pathname; otherwise don't print out
               a Directory: listing */
            if(strchr(currentfile, '/') && strncmp(old_dir, dirn, PATH_MAX) != 0)
            {
                /* Print information about the file */
                fprintf(stderr, "\n");
                fprintf(stderr,"Directory: %s/\n", dirn);
                
                strncpy(old_dir, dirn, PATH_MAX);
                old_dir[PATH_MAX-1] = '\0';
            }
            
            /* print a newline between different songs only, not after
               Directory: listing */
            else
            {
                fprintf(stderr, "\n");
            }

            fprintf(stderr,"Playing MPEG stream from %s ...\n", basen);
    
            free(dirc);
            free(basec);
        }    

        signal(SIGINT, handle_signals);

        /* Every time the user gets us to rewind, we exit decoding,
           reinitialize it, and re-start it */
        while (1)
        {
            mad_decoder_run(&decoder, MAD_DECODER_MODE_SYNC);
            
            /* if we're rewinding on an mmap()ed stream */
            if(status == MPG321_REWINDING && playbuf.fd == -1) 
            {
                mad_decoder_init(&decoder, &playbuf, read_from_mmap, read_header, /*filter*/0,
                    output, /*error*/0, /* message */ 0);
            }    
            else
                break;
        } 

        if (!(options.opt & MPG321_QUIET_PLAY))
        {
            char time_formatted[11];
            mad_timer_string(current_time, time_formatted, "%.1u:%.2u", MAD_UNITS_MINUTES,
                       MAD_UNITS_SECONDS, 0);
            fprintf(stderr, "\n[%s] Decoding of %s finished.\n",time_formatted, basename(currentfile));
        }
        
        if (options.opt & MPG321_REMOTE_PLAY && status == MPG321_STOPPED)
        {
            clear_remote_file(pl);
        }

        mad_decoder_finish(&decoder);

        if (quit_now)
            break;

        if (playbuf.frames)
             free(playbuf.frames);

        if (playbuf.times)
            free(playbuf.times);
            
        if (playbuf.fd == -1)
        {
            munmap(playbuf.buf, playbuf.length);
        }

        else
        {
            free(playbuf.buf);
            if (playbuf.fd != fileno(stdin)) 
                close(playbuf.fd);
        }
    }

    if(playdevice)
        ao_close(playdevice);

    ao_shutdown();

#if defined(RAW_SUPPORT) || defined(HTTP_SUPPORT) || defined(FTP_SUPPORT) 
    if(fd) close(fd);
#endif

    return(0);
}
Example #20
0
//====================================== Main===========================================//
int main(int argc, char **argv)
{
	int sd;
	struct sockaddr saddr;
	int r, i, j, m, n;
	struct sockaddr inaddr;
	unsigned int inlen;
	unsigned int conn;
	int child_id;
	reservation newRes;
	char buffer[BSIZE];
	struct timeval stop;
	
	
	//Defining signal handlers 
	signal(SIGCHLD,sig_chld);
	signal(SIGINT,sig_int);

	//Shared memory creation 
	sh_mem_id=shmget((key_t)SH_MEM_NAME,(size_t) sizeof(data),(int) (0600|IPC_CREAT));
	if(sh_mem_id<0)
	{
		printf("Failed to create shared memory.\n");
		exit(1);
	}
	
	//Attach server to shared memory 
	sh_mem=(data*)shmat(sh_mem_id,NULL,0);
	if(sh_mem==(data*)-1)
	{
		printf("Failed to attach server to shared memory.\n");
		exit(1);
	}
	
	//Initialize shared data. We use the arguments defined in Myheader.h.
	init_data(NUMBER_OF_OPERATORS, NUMBER_OF_TERMINALS, A_SEATS, B_SEATS, C_SEATS, D_SEATS);
	
/*///////////////////////////////////////////////////////////////////////////////////////////////
						THEATER CHECK -PROCESS 

After next line we create a new process that it continously checks,if all class get empty.
When this happen it set 'theater status' into full.
In the end, it prints several information about the reservations,
such as a foreground of the theater.

This process runs simultaneously with its parent.
//////////////////////////////////////////////////////////////////////////////////////////////*/
	if ( fork() == 0 ) { 
	//Only Child process hets in here.	
	
		//Child gets shared memory handler
		sh_mem_id=shmget((key_t)SH_MEM_NAME,sizeof(data),0600); 
		if(sh_mem_id<0)
		{
			printf("Child failed to retrieve shared memory handler.\n");
			exit(1);
		}
		//Child is attached to shared memory.
		sh_mem=(data*)shmat(sh_mem_id,NULL,0);
		if(sh_mem==(data*)-1)
		{
			printf("Failed to attach child to shared memory.\n");
			exit(1);
		}
		
		//Infinite loop used to check if theater gets Full.
		while(1){
			
			/*Check every class if they are empty*/
			if(sh_mem->Theater[1]==0 && sh_mem->Theater[2]==0 && sh_mem->Theater[3]==0 && sh_mem->Theater[4]==0 ){
						sh_mem->Theater[0]=1; //If all classes are empty, set 'theater status' full. 
						sleep(2); // 2 secands delay. 
					}
			/*Check if theater is full*/
			if(sh_mem->Theater[0]==1){
				printf("===================================================================");
				printf("\nTheater got FULL. \nTheater server will now close.\n");
				int a=((double)sh_mem->com/(sh_mem->com+sh_mem->incom))*100;
				int b=((double)sh_mem->incom/(sh_mem->com+sh_mem->incom))*100;
				printf("\n---Completed Reservations:%d  Incompleted:%d \n",sh_mem->com,sh_mem->incom);
				printf("Percent of completed reservations: %d%% \n",a);
				printf("Percent of incompleted reservations: %d%% \n",b);				
				printf("Theater Income=%d E.\n",sh_mem->Theater_account);
				printf("--Theater reservations's foreground--	\n");
				
				/*--------Printing the foreground of Class A ------*/
				printf("-Class A: \n");
				//checking every reservation
				for(m=0; m< NUM_RES; m++){ 
					//Checking if this reservation is about Class A &&
					//if this reservation is done.
					if(sh_mem->reservations[m].info[0]==0 && sh_mem->reservations[m].info[5]==1){
						//Printing the reservation's number: one time per seat
						for (i=0; i<=sh_mem->reservations[m].info[1]; i++);{
							printf("[%d]",m);
						}
					}
				}	
				/*--------Printing the foreground of Class B ------*/
				printf("\n-Class B: \n");
				//checking every reservation
				for(m=0; m< NUM_RES; m++){
					//Checking if this reservation is about Class A &&
					//if this reservation is done.
					if(sh_mem->reservations[m].info[0]==1 && sh_mem->reservations[m].info[5]==1){
						//Printing the reservation's number: one time per seat
						for (n=0; n<=sh_mem->reservations[m].info[1]; n++);{
							printf("[%d]",m);
						}
					}
				}	
				/*--------Printing the foreground of Class C ------*/
				printf("\n-Class C: \n");
				//checking every reservation
				for(m=0; m< NUM_RES; m++){
					//Checking if this reservation is about Class A &&
					//if this reservation is done.
					if(sh_mem->reservations[m].info[0]==2 && sh_mem->reservations[m].info[5]==1){
						//Printing the reservation's number: one time per seat
						for (i=0; i<=sh_mem->reservations[m].info[1]; i++);{
							printf("[%d]",m);
						}
					
					}
				}	
				/*--------Printing the foreground of Class D ------*/
				printf("\n-Class D: \n");
				//checking every reservation
				for(m=0; m< NUM_RES; m++){
					//Checking if this reservation is about Class A &&
					//if this reservation is done.
					if(sh_mem->reservations[m].info[0]==3 && sh_mem->reservations[m].info[5]==1){
						//Printing the reservation's number: one time per seat
						for (i=0; i<=sh_mem->reservations[m].info[1]; i++);{
							printf("[%d]",m);
						}
					}
				}
				printf("\n");
				printf(" Press ctrl-c to close server....");
				break;	//breaking while
			}
		}
		exit(0);	//End of process
	}
	
/*///////////////////////////////////////////////////////////////////////////////////////////////
						TRANSFER MONEY -PROCESS 

After next line we create a new process that is transfering the income of the reservations.
from Company_account to Theater_account.

This process runs simultaneously with its parent.
//////////////////////////////////////////////////////////////////////////////////////////////*/
	if ( fork() == 0 ) { 
	//Only Child process hets in here.
		//Child gets shared memory handler
		sh_mem_id=shmget((key_t)SH_MEM_NAME,sizeof(data),0600); 
		if(sh_mem_id<0)
		{
			printf("Child failed to retrieve shared memory handler.\n");
			exit(1);
		}
		
		//Child is attached to shared memory.
		sh_mem=(data*)shmat(sh_mem_id,NULL,0);
		if(sh_mem==(data*)-1)
		{
			printf("Failed to attach child to shared memory.\n");
			exit(1);
		}
		
		
		//Infinite loop used to keep the process opened.
		while(1){
			if(sh_mem->Theater[0]==0){
			sleep(TRANSFER_TIME); 	// <TRANSFER_TIME> between each transfer.
			sem_wait(sh_mem->res_sem);	//locking res_sem to make the transfer
			//printf("\n***********************************\n");
			//printf("Funds transfered to Theater account: %d E",sh_mem->Company_account);
			sh_mem->Theater_account=sh_mem->Theater_account+sh_mem->Company_account;	//transfer
			sh_mem->Company_account=0;	//Initializing company's account
			//printf("\n***********************************\n");
			sem_post(sh_mem->res_sem);	//leaving res_sem
			}
			else if(sh_mem->Theater[0]==1){
				break; // If theater got full, break 'while' and  end the process. 
			}
		}
		exit(0);	//End of process
	}
//---------------------------------------------------------------------------------------OPERATORS
/*///////////////////////////////////////////////////////////////////////////////////////////////
						OPERATORS -PROCESS 

We create <NUM_OF_OPERATORS> new processes, which act like the operators of our company.

These processes run simultaneously with their parent.
//////////////////////////////////////////////////////////////////////////////////////////////*/
	for (i=0; i<sh_mem->operators; i++) {
	//Only Child process hets in here.
		child_id=fork();
		if(child_id==0)
		{
			/*Child gets shared memory handler*/
			sh_mem_id=shmget((key_t)SH_MEM_NAME,sizeof(data),0600); 
			if(sh_mem_id<0)
			{
				printf("Child failed to retrieve shared memory handler.\n");
				exit(1);
			}
			
			/*Child is attached to shared memory.*/
			sh_mem=(data*)shmat(sh_mem_id,NULL,0);
			if(sh_mem==(data*)-1)
			{
				printf("Failed to attach child to shared memory.\n");
				exit(1);
			}
			
			//---------------------------------------------------------------------------------
			
			//Infinite loop.
			//If there are reservations, serve them.
			while(1) {
				sem_wait(sh_mem->oper_sem); 	//Locking oper_sem		
				/*Only one process gets in here each time*/
				if(sh_mem->res_head < sh_mem->res_tail && sh_mem->reservations[sh_mem->res_head].info[4]!=3 ) {

					int head = sh_mem->res_head;	//From now on use "head" as the process's ID
					
					//Inform the qeue of reservations ,which reservation is first in line.
					sh_mem->res_head++;		
					
					//Set in terminal's qeue,this process ID 
					sh_mem->term_tail++;
					
					sem_post(sh_mem->oper_sem);		//Leaving oper_sem  



					//From now on use "seatsClass" as the current reservation's class
					int seatsClass = sh_mem->reservations[head].info[0];	
					//From now on use "seatsNum" as the current reservation's Number of seats
					int seatsNum = sh_mem->reservations[head].info[1];	

					
					//printf("Checking number of available seats...\n");   
					
					//Check if 'A' is our current reservation's class
					if (sh_mem->reservations[head].info[0]==0){ 
					//Check if available seats in Class A are enough for current reservation						
						if(sh_mem->reservations[head].info[1] >sh_mem->Theater[1]){
							//printf ("No seat available in Class A\n");
							sh_mem->reservations[head].info[5]=3;//(info[5]=3)=No available seats in this Class.
						}
					}
					//Check if 'B' is our current reservation's class
					if (sh_mem->reservations[head].info[0]==1){ 
					//Check if available seats in Class B are enough for current reservation					

						if(sh_mem->reservations[head].info[1] >sh_mem->Theater[2]){
							//printf ("No seat available in Class B\n");
							sh_mem->reservations[head].info[5]=3;//(info[5]=3)=No available seats in this Class.
						}
					}
					//Check if 'C' is our current reservation's class
					if (sh_mem->reservations[head].info[0]==2){ 
					//Check if available seats in Class C are enough for current reservation						

						if(sh_mem->reservations[head].info[1] >sh_mem->Theater[3]){
							//printf ("No seat available in Class C\n");
							//If available seats aren't enough 
							sh_mem->reservations[head].info[5]=3; //(info[5]=3)=No available seats in this Class.
						}
					}
					//Check if 'D' is our current reservation's class
					if (sh_mem->reservations[head].info[0]==3){ 
					//Check if available seats in Class D are enough for current reservation						

						if(sh_mem->reservations[head].info[1] >sh_mem->Theater[4]){
							//printf ("No seat available in Class D\n");
							sh_mem->reservations[head].info[5]=3;//(info[5]=3)=No available seats in this Class.
						}

					}
					
					// "Checking for Seats"
					sleep(SEATFIND_TIME); // <SEATFIND_TIME> delay
					
					/*----At this point seats are ckecked---------*/
					
					/*Cheking if we have any 'asnwer' from the Bank (terminals*/
					while(1){  
					if(sh_mem->reservations[head].info[4]==2){
						//(info[5]=3)=Checked for available seats and Consumer's bank account. 
						break;	
						}
					}
					
					/*-------------At this point seats and client's account are ckecked-----------------------*/
					
					
					/*Checking the value of info[5].
					-If its 2,then: wrong card_ID/Insufficient account's balance.
					-If its 3,then there are not enough seats in this Class.
					If none of these happen,we can continue in reserving the seats.		*/
					if(sh_mem->reservations[head].info[5] != 2 && sh_mem->reservations[head].info[5] != 3){ //dhladh entaksei me thn karta kai me theseis

						//---------------Check if 'A' is our current reservation's class
						if (sh_mem->reservations[head].info[0]==0){ 
							sem_wait(sh_mem->seat_sem);		//Locking seat_sem	
							//SECOND check if available seats in Class A are enough for current reservation.
							if(sh_mem->reservations[head].info[1] >sh_mem->Theater[1]){
								//printf ("Seats taken in A class by another Operator.\n");
								sh_mem->reservations[head].info[5]=3;//(info[5]=3)=No available seats in this Class.
							}
							else{
								//Bring up to date Class's variable -> Theater[1]=Class A 
								sh_mem->Theater[1]=sh_mem->Theater[1]-seatsNum;
								//Counting the tickets's cost and saving it.
								//info[3]=Cost
								sh_mem->reservations[head].info[3]=sh_mem->reservations[head].info[1]*50;
								sh_mem->reservations[head].info[5]=1;//(info[5]=1)=Done. ->Current reservation is completed.
							}
							sem_post(sh_mem->seat_sem);		//Leaving seat_sem	
						}
						//---------------Check if 'B' is our current reservation's class
						if (sh_mem->reservations[head].info[0]==1){ 
							sem_wait(sh_mem->seat_sem);		//Locking seat_sem
							//SECOND check if available seats in Class B are enough for current reservation.							
							if(sh_mem->reservations[head].info[1] >sh_mem->Theater[2]){
								//printf ("Seats taken in B class by another Operator.\n");
								sh_mem->reservations[head].info[5]=3;//(info[5]=3)=No available seats in this Class.
							}
							else{
								//Bring up to date Class's variable -> Theater[2]=Class B 
								sh_mem->Theater[2]=sh_mem->Theater[2]-seatsNum;
								//Counting the tickets's cost and saving it.
								//info[3]=Cost
								sh_mem->reservations[head].info[3]=sh_mem->reservations[head].info[1]*40;
								sh_mem->reservations[head].info[5]=1;//(info[5]=1)=Done. ->Current reservation is completed.
							}
							sem_post(sh_mem->seat_sem);		//Leaving seat_sem	
						}
						//---------------Check if 'C' is our current reservation's class
						if (sh_mem->reservations[head].info[0]==2){ 
							
							sem_wait(sh_mem->seat_sem);		//Locking seat_sem
							//SECOND check if available seats in Class C are enough for current reservation.							
							if(sh_mem->reservations[head].info[1] >sh_mem->Theater[3]){
								//printf ("Seats taken in C class by another Operator.\n");
								sh_mem->reservations[head].info[5]=3;//(info[5]=3)=No available seats in this Class.
								
							}
							else{
								//Bring up to date Class's variable -> Theater[3]=Class C 
								sh_mem->Theater[3]=sh_mem->Theater[3]-seatsNum;
								//Counting the tickets's cost and saving it.
								//info[3]=Cost
								sh_mem->reservations[head].info[3]=sh_mem->reservations[head].info[1]*35;
								sh_mem->reservations[head].info[5]=1;//(info[5]=1)=Done. ->Current reservation is completed.
							}
							sem_post(sh_mem->seat_sem);		//Leaving seat_sem	
						}
						//---------------Check if 'D' is our current reservation's class
						if (sh_mem->reservations[head].info[0]==3){
							
							sem_wait(sh_mem->seat_sem);		//Locking seat_sem
							//SECOND check if available seats in Class D are enough for current reservation.							
							if(sh_mem->reservations[head].info[1] >sh_mem->Theater[4]){
								//printf ("Seats taken in D class by another Operator.\n");
								sh_mem->reservations[head].info[5]=3;//(info[5]=3)=No available seats in this Class.
							}
							else{
								//Bring up to date Class's variable -> Theater[4]=Class D
								sh_mem->Theater[4]=sh_mem->Theater[4]-seatsNum;
								//Counting the tickets's cost and saving it.
								//info[3]=Cost
								sh_mem->reservations[head].info[3]=sh_mem->reservations[head].info[1]*30; 
								sh_mem->reservations[head].info[5]=1;//(info[5]=1)=Done. ->Current reservation is completed.
							}
							sem_post(sh_mem->seat_sem);		//Leaving seat_sem	
						}

						/*At this point, seats are saved.*/
							
							
						sh_mem->reservations[head].info[4]=3;//(info[4]=3)=Reservation process ended.
						
						
						if(sh_mem->reservations[head].info[5]==3){
							//if there weren't enough available seats in the class we wanted (info[5]=3) 
							//print a message in our screen
							//printf("Reservation %d Incompleted:\nNot enough seats.(Seats taken by another Operator.\n",head);
						}
						else if(sh_mem->reservations[head].info[5]==1){
						//our reservations is completed 
						//(info[5]=1)=Done.
						
							gettimeofday(&stop, NULL);
							//Printing all the information we want to know about our current reservation 
							printf("Reservation %d Completed!, %d seats of class %d  %f msec\n", head, seatsNum, seatsClass, (float) (stop.tv_sec-sh_mem->reservations[head].reserveTime.tv_sec) * 1000000 + (stop.tv_usec-sh_mem->reservations[head].reserveTime.tv_usec));
						}
						
						//Printing Current available theater seats.
						//printf("\nCurrent available theater seats: A:%d B:%d C:%d D:%d \n",sh_mem->Theater[1],sh_mem->Theater[2],sh_mem->Theater[3],sh_mem->Theater[4]);

					}	
					else{
					//In our first check there weren't enough seats 
					printf("Reservation %d Incompleted:\nNot enough seats or insufficient account's balance/inaccurate cardID. \n",head);
					sh_mem->reservations[head].info[4]=3;//(info[4]=3)=Reservation process ended.
					}
				}
				else {
					sem_post(sh_mem->oper_sem);//Leaving oper_sem 
					//Everytime there is no reservation in our qeue, leave oper_sem and wait to check again.
				}
			}
			exit(0);
		}
	}
// --------------------------------------------------------------------------------------TERMINALS
/*///////////////////////////////////////////////////////////////////////////////////////////////
						OPERATORS -PROCESS 

We create <NUM_OF_TERMINALS> new processes, which act like the terminals of the bank.

These processes run simultaneously with their parent.
//////////////////////////////////////////////////////////////////////////////////////////////*/
	for (j=0; j<sh_mem->terminals; j++) {
		child_id=fork();
		if(child_id==0){
			//Child gets shared memory handler
			sh_mem_id=shmget((key_t)SH_MEM_NAME,sizeof(data),0600); 
			if(sh_mem_id<0)
			{
				printf("Child failed to retrieve shared memory handler.\n");
				exit(1);
			}
			
			//Child is attached to shared memory.
			sh_mem=(data*)shmat(sh_mem_id,NULL,0);
			if(sh_mem==(data*)-1)
			{
				printf("Failed to attach child to shared memory.\n");
				exit(1);
			}
			

			
			/*read queue, if there is work do it */
			while(1) {
				sem_wait(sh_mem->term_sem); //elegxos an yparxei diathesimo terminal			
				if(sh_mem->term_head < sh_mem->term_tail) {

					int head = sh_mem->term_head;//!!!!!!!!!!!!!!!!
					sh_mem->term_head++;

					sem_post(sh_mem->term_sem);

					
					//printf("Checking cardID and account's balance...\n");
					//periptwsh apotyxias
					if (percent_value(head)==7){
						sh_mem->reservations[head].info[5] = 2;
					}

					//////////////////////////////
					sleep(CARDCHECK_TIME);
					///////////////////////////
			
					
					sh_mem->reservations[head].info[4]=2; // CHECKED
				}
				else {
					sem_post(sh_mem->term_sem);
				}
			}
			exit(0);
		}
	}
//////////////////////////////////////////////////////////////////////////////////////////////////////	

//--------------------------------SOCKETS-----------------------------------------------//
	/*Getting a socket handler*/
	sd=socket(AF_UNIX,SOCK_STREAM,0);
	if(sd<0)
	{
		printf("Error in creating socket.\n");
		exit(1);
	}

	/*Delete socket file if already exists*/
	unlink(SOCKET_NAME);  // "MySock"

	/*Specify socket address details*/
	saddr.sa_family = AF_UNIX;
	strcpy(saddr.sa_data,SOCKET_NAME);
	/*Bind socket*/
	r=bind(sd,&saddr,sizeof(saddr));
	if(r<0)
	{
		printf("Error in binding socket.\n");
		exit(1);
	}	
	/*Listen to socket*/
	r=listen(sd,1); /*size of listening queue is 1*/
	if(r<0)
	{
		printf("Error in listening.\n");
		exit(1);
	}
	
	
	while(1) //
	{
		inlen=sizeof(inaddr);

		/*Wait for connection attempt*/
		conn=accept(sd,&inaddr,&inlen);
		if(conn<0)
		{
			printf("Connection attempt failed.\n");
			continue;
		}
		
		/*Connection established, spawn a child to serve it*/
		child_id=fork();
		if(child_id==0)
		{
			signal(SIGUSR1,sig_res);
			
			/*Child gets shared memory handler*/
			sh_mem_id=shmget((key_t)SH_MEM_NAME,sizeof(data),0600); 
			if(sh_mem_id<0)
			{
				printf("Child failed to retrieve shared memory handler.\n");
				exit(1);
			}
			
			/*Child is attached to shared memory.*/
			sh_mem=(data*)shmat(sh_mem_id,NULL,0);
			if(sh_mem==(data*)-1)
			{
				printf("Failed to attach child to shared memory.\n");
				exit(1);
			}
			
			/*read user reservation*/
			read(conn,&newRes,sizeof(reservation));
			
			
			
			//printf("-------------------------------------------------------------\n");
			/*TODO:add reservation to queue*/
			/*TODO:add pid to queue*/
			sem_wait(sh_mem->res_sem);  		// trying to get res_sem opened
			int resNum = sh_mem->res_tail;		
			sh_mem->reservations[sh_mem->res_tail].info[0] = newRes.info[0]; //CLASS
			sh_mem->reservations[sh_mem->res_tail].info[1] = newRes.info[1]; //NUMBER
			sh_mem->reservations[sh_mem->res_tail].info[2] = newRes.info[2]; //CARD_ID
			sh_mem->reservations[sh_mem->res_tail].info[4] = 1; //STATUS -diavasthke
			
			if(sh_mem->Theater[0]==1){
				//If Theater is full set Curretnt reservation's status:
				//(info[4]=3)-Reservation process ended
				sh_mem->reservations[resNum].info[4]=3;
			}
			sh_mem->reservations[sh_mem->res_tail].procNumber = getpid();
			
			gettimeofday(&(sh_mem->reservations[sh_mem->res_tail].reserveTime), NULL);
			sh_mem->res_tail++;
			sem_post(sh_mem->res_sem);		 // leaving the oper_sem
			
			if(sh_mem->Theater[0]==0){
			
				while(1){  //Checking current reservation's status
				if(sh_mem->reservations[resNum].info[4]==3){
					break;	
					}
				}
			}
			else{
				
				sh_mem->reservations[resNum].info[5]=4;
				//printf("Current reservation incompleted!\nTheater if FULL.\n No further reservations can be accepted. \n");
			}
			
			
			 switch (sh_mem->reservations[resNum].info[5]) {
                case 1:
                        sprintf(buffer, "Reservation %d completed !\nClass: %d\nSeats Number: %d\ncard_ID: %d \nCost: %d E",resNum, sh_mem->reservations[resNum].info[0], sh_mem->reservations[resNum].info[1], sh_mem->reservations[resNum].info[2],sh_mem->reservations[resNum].info[3]);	
						sem_wait(sh_mem->res_sem);
						sh_mem->Company_account=sh_mem->Company_account+sh_mem->reservations[resNum].info[3];
						sh_mem->com++;
						sem_post(sh_mem->res_sem);	
						break;
				case 2:
                        sprintf(buffer, "Reservation %d incompleted !\nInaccurate cardID or insufficient account's balance.",resNum);				
						sem_wait(sh_mem->res_sem);
						sh_mem->incom++;
						sem_post(sh_mem->res_sem);	
						break;
				case 3:
                        sprintf(buffer,"Reservation %d incompleted !\nNo seats available in this Class.",resNum);				
						sem_wait(sh_mem->res_sem);
						sh_mem->incom++;
						sem_post(sh_mem->res_sem);	
						break;
				case 4:
                        sprintf(buffer, "Reservation %d incompleted !\nTheater is FULL.",resNum);				
						sem_wait(sh_mem->res_sem);
						sh_mem->incom++;
						sem_post(sh_mem->res_sem);	
						break;
				default:
						sprintf(buffer, "Kati paixthke me th diergasia %d",resNum);	
			}

			write(conn,buffer,BSIZE);
			
			semaphores_close();

			/*deattach child from shared memory*/
			r=shmdt(sh_mem); 
			if(r<0)
			{	
				printf("Failed to deattach child from shared memory.\n");
				exit(1);
			}
			exit(0);
		}
		close(conn);
	}
	exit(0); //!!!!!!!!!!!
}
Example #21
0
int main(int argc, char **argv)
{
char *temp, *s;
	char*	displayName = NULL;

  commands=NULL;

  /* Save the program name for error messages and config parsing */
  temp = argv[0];
  s=strrchr(argv[0], '/');
  if (s != NULL)
    temp = s + 1;

  Module=temp;

  if((argc != 6)&&(argc != 7)) {
    fprintf(stderr,"%s Version %s should only be executed by fvwm!\n",Module,
      VERSION);
   exit(1);
  }

  Fvwm_fd[0] = atoi(argv[1]);
  Fvwm_fd[1] = atoi(argv[2]);

  /* Grab the X display information now. */

	dpy = XOpenDisplay(displayName);
	if (!dpy)
	{
		fprintf(stderr, "%s:  unable to open display '%s'\n",
			Module, XDisplayName (displayName));
		exit (2);
	}
	screen = DefaultScreen(dpy);
	root = RootWindow(dpy, screen);

	/* Open a log file if necessary */
#	ifdef LOGFILE
		logFile = fopen(LOGFILE,"a");
		fprintf(logFile,"Initialising FvwmBacker\n");
#	endif

  signal (SIGPIPE, DeadPipe);

  /* Parse the config file */
  ParseConfig();

  fd_width = GetFdWidth();

  SetMessageMask(Fvwm_fd,M_NEW_DESK|M_CONFIG_INFO|M_END_CONFIG_INFO);

  /*
  ** we really only want the current desk, and window list sends it
  */
  SendInfo(Fvwm_fd,"Send_WindowList",0);


  /* Recieve all messages from Fvwm */
  EndLessLoop();

  /* Should never get here! */
  return 1;
}
Example #22
0
File: tty00.c Project: OSLL/pmover
int main(int argc, char ** argv)
{
	int fdm, fds, status;
	char *slavename;
	pid_t pid;

	test_init(argc, argv);

	fdm = open("/dev/ptmx", O_RDWR);
	if (fdm == -1) {
		err("Can't open a master pseudoterminal");
		return 1;
	}

	grantpt(fdm);
	unlockpt(fdm);
	slavename = ptsname(fdm);

	pid = test_fork();
	if (pid < 0) {
		err("fork() failed");
		return 1;
	}

	if (pid == 0) {
		close(fdm);
		signal(SIGHUP, sighup_handler);

		if (setsid() == -1)
			return 1;

		/* set up a controlling terminal */
		fds = open(slavename, O_RDWR);
		if (fds == -1) {
			err("Can't open a slave pseudoterminal %s", slavename);
			return 1;
		}

		if (ioctl(fdm, TIOCSCTTY, 1) < 0) {
			err("Can't setup a controlling terminal");
			return 1;
		}
		close(fds);

		test_waitsig();
		if (sighup)
			return 0;
		return 1;
	}


	test_daemon();

	test_waitsig();

	close(fdm);

	if (kill(pid, SIGTERM) == -1) {
		err("kill failed");
		return 1;
	}

	pid = waitpid(pid, &status, 0);
	if (pid < 0)
		return 1;

	if (WIFEXITED(status)) {
		if (WEXITSTATUS(status)) {
			fail("The child returned %d", WEXITSTATUS(status));
			return 1;
		}
	} else
		err("The child has been killed by %d", WTERMSIG(status));

	pass();

	return 0;
}
Example #23
0
int64 io_waituntil2(int64 milliseconds) {
#ifndef __MINGW32__
  struct pollfd* p;
#endif
  long i,j,r;
  if (!io_wanted_fds) return 0;
#ifdef HAVE_EPOLL
  if (io_waitmode==EPOLL) {
    int n;
    struct epoll_event y[50];
    if ((n=epoll_wait(io_master,y,50,milliseconds))==-1) return -1;
    
    int first_new = -1;
    int last_new = -1;
    for (i=n-1; i>=0; --i) {
      io_entry* e=array_get(&io_fds,sizeof(io_entry),y[i].data.fd);
      if (e) {
	if (y[i].events&(EPOLLERR|EPOLLHUP)) {
	  /* error; signal whatever app is looking for */
	  if (e->wantread) y[i].events|=EPOLLIN;
	  if (e->wantwrite) y[i].events|=EPOLLOUT;
	}
#ifdef EPOLLRDNORM
	if (y[i].data.fd == io_master && !e->canread && (y[i].events&(EPOLLIN|EPOLLPRI|EPOLLRDNORM|EPOLLRDBAND))) {
#else
	if (y[i].data.fd == io_master && !e->canread && (y[i].events&(EPOLLIN|EPOLLPRI))) {
#endif
	  e->canread=1;
	  e->next_read=first_new;
	  if(first_new == -1) last_new = y[i].data.fd;
	  first_new=y[i].data.fd;
	}
      }
    }

    //if(n > 1) printf("n: %d\n", n);
    for (i=n-1; i>=0; --i) {
    //for (i=0; i < n; i++) {
      io_entry* e=array_get(&io_fds,sizeof(io_entry),y[i].data.fd);
      if (e) {
#ifdef EPOLLRDNORM
	if (!e->canread && (y[i].events&(EPOLLIN|EPOLLPRI|EPOLLRDNORM|EPOLLRDBAND))) {
#else
	if (!e->canread && (y[i].events&(EPOLLIN|EPOLLPRI))) {
#endif
	  e->canread=1;
	  e->next_read=first_readable;
	  first_readable=y[i].data.fd;
	}
	if (!e->canwrite && (y[i].events&EPOLLOUT)) {
	  e->canwrite=-1;
	  e->next_write=first_writeable;
	  first_writeable=y[i].data.fd;
	}
      } else {
	epoll_ctl(io_master,EPOLL_CTL_DEL,y[i].data.fd,y+i);
      }
    }

    // if there are new connections, put them first...
    if(last_new != -1) {
      if(first_readable != -1) {
        io_entry* e=array_get(&io_fds,sizeof(io_entry),last_new);
        e->next_read=first_readable;
      }

      first_readable = first_new;
    }
 

    return n;
  }
#endif
#ifdef HAVE_KQUEUE
  if (io_waitmode==KQUEUE) {
    struct kevent y[100];
    int n;
    struct timespec ts;
    ts.tv_sec=milliseconds/1000; ts.tv_nsec=(milliseconds%1000)*1000000;
    if ((n=kevent(io_master,0,0,y,100,milliseconds!=-1?&ts:0))==-1) return -1;
    for (i=n-1; i>=0; --i) {
      io_entry* e=array_get(&io_fds,sizeof(io_entry),y[--n].ident);
#ifdef DEBUG
      if (!e) {
	e=e;
      }
#endif
      if (e) {
	if (y[n].flags&EV_ERROR) {
	  /* error; signal whatever app is looking for */
	  if (e->wantread) y[n].filter=EVFILT_READ; else
	  if (e->wantwrite) y[n].filter=EVFILT_WRITE;
	}
	if (!e->canread && (y[n].filter==EVFILT_READ)) {
	  e->canread=1;
	  e->next_read=first_readable;
	  first_readable=y[n].ident;
	}
	if (!e->canwrite && (y[n].filter==EVFILT_WRITE)) {
	  e->canwrite=1;
	  e->next_write=first_writeable;
	  first_writeable=y[i].ident;
	}
#ifdef DEBUG
      } else {
	fprintf(stderr,"got kevent on fd#%d, which is not in array!\n",y[n].ident);
#endif
      }
    }
    return n;
  }
#endif
#ifdef HAVE_DEVPOLL
  if (io_waitmode==DEVPOLL) {
    dvpoll_t timeout;
    struct pollfd y[100];
    int n;
    timeout.dp_timeout=milliseconds;
    timeout.dp_nfds=100;
    timeout.dp_fds=y;
    if ((n=ioctl(io_master,DP_POLL,&timeout))==-1) return -1;
    for (i=n-1; i>=0; --i) {
      io_entry* e=array_get(&io_fds,sizeof(io_entry),y[--n].fd);
      if (e) {
	if (y[n].revents&(POLLERR|POLLHUP|POLLNVAL)) {
	  /* error; signal whatever app is looking for */
	  if (e->wantread) y[n].revents=POLLIN;
	  if (e->wantwrite) y[n].revents=POLLOUT;
	}
	if (!e->canread && (y[n].revents&POLLIN)) {
	  e->canread=1;
	  if (e->next_read==-1) {
	    e->next_read=first_readable;
	    first_readable=y[n].fd;
	  }
	}
	if (!e->canwrite && (y[n].revents&POLLOUT)) {
	  e->canwrite=1;
	  if (e->next_write==-1) {
	    e->next_write=first_writeable;
	    first_writeable=y[i].fd;
	  }
	}
#ifdef DEBUG
      } else {
	fprintf(stderr,"got kevent on fd#%d, which is not in array!\n",y[n].fd);
#endif
      }
    }
    return n;
  }
#endif
#ifdef HAVE_SIGIO
  if (io_waitmode==_SIGIO) {
    siginfo_t info;
    struct timespec ts;
    int r;
    io_entry* e;
    if (alt_firstread>=0 && (e=array_get(&io_fds,sizeof(io_entry),alt_firstread)) && e->canread) return 1;
    if (alt_firstwrite>=0 && (e=array_get(&io_fds,sizeof(io_entry),alt_firstwrite)) && e->canwrite) return 1;
    if (milliseconds==-1)
      r=sigwaitinfo(&io_ss,&info);
    else {
      ts.tv_sec=milliseconds/1000; ts.tv_nsec=(milliseconds%1000)*1000000;
      r=sigtimedwait(&io_ss,&info,&ts);
    }
    switch (r) {
    case SIGIO:
      /* signal queue overflow */
      signal(io_signum,SIG_DFL);
      goto dopoll;
    default:
      if (r==io_signum) {
	io_entry* e=array_get(&io_fds,sizeof(io_entry),info.si_fd);
	if (e) {
	  if (info.si_band&(POLLERR|POLLHUP)) {
	    /* error; signal whatever app is looking for */
	    if (e->wantread) info.si_band|=POLLIN;
	    if (e->wantwrite) info.si_band|=POLLOUT;
	  }
	  if (info.si_band&POLLIN && !e->canread) {
	    debug_printf(("io_waituntil2: enqueueing %ld in normal read queue before %ld\n",info.si_fd,first_readable));
	    e->canread=1;
	    e->next_read=first_readable;
	    first_readable=info.si_fd;
	  }
	  if (info.si_band&POLLOUT && !e->canwrite) {
	    debug_printf(("io_waituntil2: enqueueing %ld in normal write queue before %ld\n",info.si_fd,first_writeable));
	    e->canwrite=1;
	    e->next_write=first_writeable;
	    first_writeable=info.si_fd;
	  }
#ifdef DEBUG
	} else {
	  fprintf(stderr,"got kevent on fd#%d, which is not in array!\n",info.si_fd);
#endif
	}
      }
    }
    return 1;
  }
dopoll:
#endif
#ifdef __MINGW32__
  DWORD numberofbytes;
  ULONG_PTR x;
  LPOVERLAPPED o;
  if (first_readable!=-1 || first_writeable!=-1) {
    fprintf(stderr,"io_waituntil2() returning immediately because first_readable(%p) or first_writeable(%p) are set\n",first_readable,first_writeable);
    return;
  }
  fprintf(stderr,"Calling GetQueuedCompletionStatus %p...",io_comport);
  if (GetQueuedCompletionStatus(io_comport,&numberofbytes,&x,&o,milliseconds==-1?milliseconds:INFINITE)) {
    io_entry* e=array_get(&io_fds,sizeof(io_entry),x);
    fprintf(stderr," OK.  Got %x, e=%p\n",x,e);
    if (!e) return 0;
    e->errorcode=0;
    fprintf(stderr,"o=%p, e->or=%p, e->ow=%p, e->os=%p\n",o,&e->or,&e->ow,&e->os);
    fprintf(stderr,"e->readqueued=%d, e->writequeued=%d, e->acceptqueued=%d, e->connectqueued=%d, e->sendfilequeued=%d\n",
	    e->readqueued,e->writequeued,e->acceptqueued,e->connectqueued,e->sendfilequeued);
    if (o==&e->or && e->readqueued==1) {
      e->readqueued=2;
      e->canread=1;
      e->bytes_read=numberofbytes;
      e->next_read=first_readable;
      first_readable=x;
//      printf("read %lu bytes on fd %lu: %p\n",numberofbytes,x,e);
    } else if (o==&e->ow && e->writequeued==1) {
      e->writequeued=2;
      e->canwrite=1;
      e->bytes_written=numberofbytes;
      e->next_write=first_writeable;
      first_writeable=x;
    } else if (o==&e->or && e->acceptqueued==1) {
      e->acceptqueued=2;
      e->canread=1;
      e->next_read=first_readable;
      first_readable=x;
    } else if (o==&e->ow && e->connectqueued==1) {
      e->connectqueued=2;
      e->canwrite=1;
      e->next_write=first_writeable;
      first_writeable=x;
    } else if (o==&e->os && e->sendfilequeued==1) {
      e->sendfilequeued=2;
      e->canwrite=1;
      e->bytes_written=numberofbytes;
      e->next_write=first_writeable;
      first_writeable=x;
    }
    return 1;
  } else {
    /* either the overlapped I/O request failed or we timed out */
    DWORD err;
    io_entry* e;
    fprintf(stderr," failure, o=%p.\n",o);
    if (!o) return 0;	/* timeout */
    /* we got a completion packet for a failed I/O operation */
    err=GetLastError();
    if (err==WAIT_TIMEOUT) return 0;	/* or maybe not */
    e=array_get(&io_fds,sizeof(io_entry),x);
    if (!e) return 0;	/* WTF?! */
    e->errorcode=err;
    if (o==&e->or && (e->readqueued || e->acceptqueued)) {
      if (e->readqueued) e->readqueued=2; else
      if (e->acceptqueued) e->acceptqueued=2;
      e->canread=1;
      e->bytes_read=-1;
      e->next_read=first_readable;
      first_readable=x;
    } else if ((o==&e->ow || o==&e->os) &&
               (e->writequeued || e->connectqueued || e->sendfilequeued)) {
      if (o==&e->ow) {
	if (e->writequeued) e->writequeued=2; else
        if (e->connectqueued) e->connectqueued=2;
      } else if (o==&e->os) e->sendfilequeued=2;
      e->canwrite=1;
      e->bytes_written=-1;
      e->next_write=first_writeable;
      first_writeable=x;
    }
    return 1;
  }
#else
  for (i=r=0; i<array_length(&io_fds,sizeof(io_entry)); ++i) {
    io_entry* e=array_get(&io_fds,sizeof(io_entry),i);
    if (!e) return -1;
    e->canread=e->canwrite=0;
    if (e->wantread || e->wantwrite) {
      struct pollfd* p;
      if ((p=array_allocate(&io_pollfds,sizeof(struct pollfd),r))) {
	p->fd=i;
	p->events=(e->wantread?POLLIN:0) + (e->wantwrite?POLLOUT:0);
	++r;
      } else
	return -1;
    }
  }
  p=array_start(&io_pollfds);
  if ((i=poll(array_start(&io_pollfds),r,milliseconds))<1) return -1;
  for (j=r-1; j>=0; --j) {
    io_entry* e=array_get(&io_fds,sizeof(io_entry),p->fd);
    if (p->revents&(POLLERR|POLLHUP|POLLNVAL)) {
      /* error; signal whatever app is looking for */
      if (e->wantread) p->revents|=POLLIN;
      if (e->wantwrite) p->revents|=POLLOUT;
    }
    if (!e->canread && (p->revents&POLLIN)) {
      e->canread=1;
      e->next_read=first_readable;
      first_readable=p->fd;
    }
    if (!e->canwrite && (p->revents&POLLOUT)) {
      e->canwrite=1;
      e->next_write=first_writeable;
      first_writeable=p->fd;
    }
    p++;
  }
  return i;
#endif
}
Example #24
0
File: main.c Project: etrunko/ibus
gint
main (gint argc, gchar **argv)
{
    setlocale (LC_ALL, "");

    GOptionContext *context = g_option_context_new ("- ibus daemon");
    g_option_context_add_main_entries (context, entries, "ibus-daemon");

    g_argv = g_strdupv (argv);
    GError *error = NULL;
    if (!g_option_context_parse (context, &argc, &argv, &error)) {
        g_printerr ("Option parsing failed: %s\n", error->message);
	g_error_free (error);
        exit (-1);
    }
    if (g_gdbus_timeout < -1) {
        g_printerr ("Bad timeout (must be >= -1): %d\n", g_gdbus_timeout);
        exit (-1);
    }

    if (g_mempro) {
        g_mem_set_vtable (glib_mem_profiler_table);
        signal (SIGUSR2, _sig_usr2_handler);
    }

    /* check uid */
    {
        const gchar *username = ibus_get_user_name ();
        uid_t uid = getuid ();
        struct passwd *pwd = getpwuid (uid);

        if (pwd == NULL || g_strcmp0 (pwd->pw_name, username) != 0) {
            g_printerr ("Please run ibus-daemon with login user! Do not run ibus-daemon with sudo or su.\n");
            exit (-1);
        }
    }

    /* daemonize process */
    if (daemonize) {
        if (daemon (1, 0) != 0) {
            g_printerr ("Can not daemonize ibus.\n");
            exit (-1);
        }
    }

    /* create a new process group. this is important to kill all of its children by SIGTERM at a time in bus_ibus_impl_destroy. */
    setpgid (0, 0);

    ibus_init ();

    ibus_set_log_handler (g_verbose);

    /* check if ibus-daemon is running in this session */
    if (ibus_get_address () != NULL) {
        IBusBus *bus = ibus_bus_new ();

        if (ibus_bus_is_connected (bus)) {
            if (!replace) {
                g_printerr ("current session already has an ibus-daemon.\n");
                exit (-1);
            }
            ibus_bus_exit (bus, FALSE);
            while (ibus_bus_is_connected (bus)) {
                g_main_context_iteration (NULL, TRUE);
            }
        }
        g_object_unref (bus);
    }

    bus_server_init ();
    if (!single) {
        /* execute config component */
        if (g_strcmp0 (config, "default") == 0) {
            BusComponent *component;
            component = bus_ibus_impl_lookup_component_by_name (
                    BUS_DEFAULT_IBUS, IBUS_SERVICE_CONFIG);
            if (component) {
                bus_component_set_restart (component, restart);
            }
            if (component == NULL || !bus_component_start (component, g_verbose)) {
                g_printerr ("Can not execute default config program\n");
                exit (-1);
            }
        } else if (g_strcmp0 (config, "disable") != 0 && g_strcmp0 (config, "") != 0) {
            if (!execute_cmdline (config))
                exit (-1);
        }

        /* execute panel component */
        if (g_strcmp0 (panel, "default") == 0) {
            BusComponent *component;
            component = bus_ibus_impl_lookup_component_by_name (
                    BUS_DEFAULT_IBUS, IBUS_SERVICE_PANEL);
            if (component) {
                bus_component_set_restart (component, restart);
            }
            if (component == NULL || !bus_component_start (component, g_verbose)) {
                g_printerr ("Can not execute default panel program\n");
                exit (-1);
            }
        } else if (g_strcmp0 (panel, "disable") != 0 && g_strcmp0 (panel, "") != 0) {
            if (!execute_cmdline (panel))
                exit (-1);
        }
    }

    /* execute ibus xim server */
    if (xim) {
        if (!execute_cmdline (LIBEXECDIR "/ibus-x11 --kill-daemon"))
            exit (-1);
    }

    bus_server_run ();
    return 0;
}
Example #25
0
File: dacq.c Project: mazerj/pype2
int dacq_start(int boot, int testmode, char *tracker_type,
	       char *dacq_server, char *trakdev)
{
  int shmid, ii;

  /* init the internal timestamper, in case it's needed later */
  timestamp(1);

  if ((shmid =
       shmget((key_t)SHMKEY, sizeof(DACQINFO), 0666 | IPC_CREAT)) < 0) {
    if (errno == EINVAL) {
      fprintf(stderr, "dacq_start: Shared memory buffer's changed sizes!\n");
      fprintf(stderr, "            Run pypekill, then try pype again.\n");
      return(0);
    } else {
      perror("shmget");
      fprintf(stderr, "dacq_start: %d kernel compiled with SHM/IPC?\n", errno);
      return(0);
    }
  }

  if ((dacq_data = shmat(shmid, NULL, 0)) == NULL) {
    perror("shmat");
    fprintf(stderr, "dacq_start: kernel compiled with SHM/IPC?\n");
    return(0);
  }

  if ((semid = psem_init(SEMKEY)) < 0) {
    perror("psem_init");
    fprintf(stderr, "dacq_start: can't init semaphore\n");
    return(0);
  } else {
    /* start semaphore off at value of 1 */
    if (psem_set(semid, 1) < 0) {
      perror("psem_init");
      return(-1);
    }
  }

  /* don't need to LOCK/UNLOCK until child processes are
   * running ... so don't bother here..
   */

  if (boot) {
    int i;

    for (i = 0; i < NDIGIN; i++) {
      dacq_data->din[i] = 0;
      dacq_data->din_changes[i] = 0;
      dacq_data->din_intmask[i] = 0;
    }

    for (i = 0; i < NDIGOUT; i++) {
      dacq_data->dout[i] = 0;
    }

    dacq_data->dout_strobe = 0;

    for (i = 0; i < NADC; i++) {
      dacq_data->adc[i] = 0;
    }

    dacq_data->eye_xgain = 1.0;
    dacq_data->eye_ygain = 1.0;
    dacq_data->eye_xoff = 0;
    dacq_data->eye_yoff = 0;

    for (i = 0; i < NFIXWIN; i++) {
      dacq_data->fixwin[i].active = 0;
      dacq_data->fixwin[i].genint = 0;
    }

    for (i = 0; i < NJOYBUT; i++) {
      dacq_data->js[i] = 0;
    }
    dacq_data->js_x = 0;
    dacq_data->js_y = 0;
    dacq_data->js_enabled = 0;

    dacq_data->adbuf_on = 0;
    dacq_data->adbuf_ptr = 0;
    dacq_data->adbuf_overflow = 0;
    for (i = 0; i < ADBUFLEN; i++) {
      dacq_data->adbuf_t[i] = 0;
      dacq_data->adbuf_x[i] = 0;
      dacq_data->adbuf_y[i] = 0;
      for (ii=0; ii < NADC; ii++) {
	dacq_data->adbufs[ii][i] = 0;
      }
    }

    for (i = 0; i < NDAC; i++) {
      dacq_data->dac[i] = 0;
    }

    dacq_data->dac_strobe = 0;

    dacq_data->timestamp = 0;
    dacq_data->terminate = 0;
    dacq_data->das_ready = 0;

    dacq_data->eye_smooth = 0;
    dacq_data->eye_x = 0;
    dacq_data->eye_y = 0;

    dacq_data->dacq_pri = 0;

    dacq_data->fixbreak_tau = 5;

    /* alarm timer (same units as timestamp); 0 for no alarm */
    dacq_data->alarm_time = 0;

    if (testmode) {
      dacq_data->din[2] = 1;
      dacq_data->din[3] = 1;
      fprintf(stderr, "dacq: testmode = 1 (no sub process!)\n");
    } else {
      signal(SIGCHLD, dacq_sigchld_handler);

      fprintf(stderr, "dacq: testmode = 0\n");
      fprintf(stderr, "dacq: tracker_type = %s\n", tracker_type);
      fprintf(stderr, "dacq: dacq_server = %s\n", dacq_server);

      if ((dacq_server_pid = fork()) == 0) {
	/* child process execs the dacq_server */

	if (strcmp(tracker_type, "ISCAN") == 0) {
	  //fprintf(stderr, "dacqmodule: starting iscan\n");
	  execlp(dacq_server, dacq_server, "-iscan", trakdev, NULL);
	} else if (strcmp(tracker_type, "EYELINK") == 0) {
	  //fprintf(stderr, "dacqmodule: starting eyelink\n");
	  execlp(dacq_server, dacq_server, "-eyelink", trakdev, NULL);
	} else if (strcmp(tracker_type, "ANALOG") == 0) {
	  //fprintf(stderr, "dacqmodule: starting analog\n");
	  execlp(dacq_server, dacq_server, NULL);
	} else if (strcmp(tracker_type, "EYEJOY") == 0) {
	  //fprintf(stderr, "dacqmodule: starting eyelink\n");
	  execlp(dacq_server, dacq_server, "-eyejoy", NULL);
	} else if (strcmp(tracker_type, "NONE") == 0) {
	  //fprintf(stderr, "dacqmodule: starting w/o tracker\n");
	  execlp(dacq_server, dacq_server, "-notracker", NULL);
	}

	perror(dacq_server);
	exit(1);
      } else {

	/* parent waits for server to become ready */
	do {
	  LOCK(semid);
	  i = dacq_data->das_ready;
	  UNLOCK(semid);
	  usleep(100);
	  } while (i == 0);
      }
    }
  }
  return(1);
}
Example #26
0
int telnet_main(int argc, char **argv)
{
	char *host;
	int port;
	int len;
#ifdef USE_POLL
	struct pollfd ufds[2];
#else
	fd_set readfds;
	int maxfd;
#endif

	INIT_G();

#if ENABLE_FEATURE_AUTOWIDTH
	get_terminal_width_height(0, &G.win_width, &G.win_height);
#endif

#if ENABLE_FEATURE_TELNET_TTYPE
	G.ttype = getenv("TERM");
#endif

	if (tcgetattr(0, &G.termios_def) >= 0) {
		G.do_termios = 1;
		G.termios_raw = G.termios_def;
		cfmakeraw(&G.termios_raw);
	}

	if (argc < 2)
		bb_show_usage();

#if ENABLE_FEATURE_TELNET_AUTOLOGIN
	if (1 & getopt32(argv, "al:", &G.autologin))
		G.autologin = getenv("USER");
	argv += optind;
#else
	argv++;
#endif
	if (!*argv)
		bb_show_usage();
	host = *argv++;
	port = bb_lookup_port(*argv ? *argv++ : "telnet", "tcp", 23);
	if (*argv) /* extra params?? */
		bb_show_usage();

	G.netfd = create_and_connect_stream_or_die(host, port);

	setsockopt(G.netfd, SOL_SOCKET, SO_KEEPALIVE, &const_int_1, sizeof(const_int_1));

	signal(SIGINT, fgotsig);

#ifdef USE_POLL
	ufds[0].fd = 0; ufds[1].fd = G.netfd;
	ufds[0].events = ufds[1].events = POLLIN;
#else
	FD_ZERO(&readfds);
	FD_SET(0, &readfds);
	FD_SET(G.netfd, &readfds);
	maxfd = G.netfd + 1;
#endif

	while (1) {
#ifndef USE_POLL
		fd_set rfds = readfds;

		switch (select(maxfd, &rfds, NULL, NULL, NULL))
#else
		switch (poll(ufds, 2, -1))
#endif
		{
		case 0:
			/* timeout */
		case -1:
			/* error, ignore and/or log something, bay go to loop */
			if (G.gotsig)
				conescape();
			else
				sleep(1);
			break;
		default:

#ifdef USE_POLL
			if (ufds[0].revents) /* well, should check POLLIN, but ... */
#else
			if (FD_ISSET(0, &rfds))
#endif
			{
				len = read(0, G.buf, DATABUFSIZE);
				if (len <= 0)
					doexit(0);
				TRACE(0, ("Read con: %d\n", len));
				handlenetoutput(len);
			}

#ifdef USE_POLL
			if (ufds[1].revents) /* well, should check POLLIN, but ... */
#else
			if (FD_ISSET(G.netfd, &rfds))
#endif
			{
				len = read(G.netfd, G.buf, DATABUFSIZE);
				if (len <= 0) {
					write_str(1, "Connection closed by foreign host\r\n");
					doexit(1);
				}
				TRACE(0, ("Read netfd (%d): %d\n", G.netfd, len));
				handlenetinput(len);
			}
		}
	}
}
Example #27
0
static void initCrashCatch()
{
    for (auto sig : s_fatal_signals) {
        signal(sig, signalHandler);
    }
}
Example #28
0
void Scene1200::sub9DAD6(int indx) {
	_object1.sub9EE22(R2_GLOBALS._v56AA2, R2_GLOBALS._v56AA4);
	
	switch (indx) {
	case 0:
		if ( ((_object1.sub51AF8(Common::Point(200, 50)) > 36) || (_object1.sub51AF8(Common::Point(200, 88)) > 36)) 
			&& ( ((R2_GLOBALS._v56AA2 == 3) && (R2_GLOBALS._v56AA4 == 33) && (_field418 != 4)) 
				|| ((R2_GLOBALS._v56AA2 == 13) && (R2_GLOBALS._v56AA4 == 21) && (_field418 != 2)) 
				|| ((R2_GLOBALS._v56AA2 == 29) && (R2_GLOBALS._v56AA4 == 17) && (_field418 != 1)) 
				|| ((R2_GLOBALS._v56AA2 == 33) && (R2_GLOBALS._v56AA4 == 41)) )
				)	{
			R2_GLOBALS._player.disableControl();
			_sceneMode = 1200;
			setAction(&_sequenceManager, this, 1200, &_actor1, NULL);
		} else if (_object1.sub51AF8(Common::Point(200, 69)) == 36) {
			switch (_field412 - 1) {
			case 0:
				if (R2_GLOBALS._player._visage == 3155)
					_sceneMode = 15;
				else
					_sceneMode = 10;
				break;
			case 1:
				if (R2_GLOBALS._player._visage == 3156)
					_sceneMode = 76;
				else
					_sceneMode = 75;
				break;
			case 2:
				if (R2_GLOBALS._player._visage == 3156)
					_sceneMode = 101;
				else
					_sceneMode = 100;
				break;
			case 3:
				if (R2_GLOBALS._player._visage == 3156)
					_sceneMode = 111;
				else
					_sceneMode = 110;
				break;
			default:
				break;
			}
			R2_GLOBALS._player.disableControl();
			_field412 = 1;
			signal();
		}
		break;
	case 1:
		if ( ((_object1.sub51AF8(Common::Point(120, 50)) > 36) || (_object1.sub51AF8(Common::Point(120, 88)) > 36)) 
			&& ( ((R2_GLOBALS._v56AA2 == 7) && (R2_GLOBALS._v56AA4 == 33) && (_field418 != 4)) 
				|| ((R2_GLOBALS._v56AA2 == 17) && (R2_GLOBALS._v56AA4 == 21) && (_field418 != 2)) 
				|| ((R2_GLOBALS._v56AA2 == 33) && (R2_GLOBALS._v56AA4 == 17) && (_field418 != 1)) 
				|| ((R2_GLOBALS._v56AA2 == 5) && (R2_GLOBALS._v56AA4 == 5)) )
				)	{
			R2_GLOBALS._player.disableControl();
			_sceneMode = 1201;
			setAction(&_sequenceManager, this, 1201, &_actor1, NULL);
		} else if (_object1.sub51AF8(Common::Point(120, 69)) == 36) {
			switch (_field412 - 1) {
			case 0:
				if (R2_GLOBALS._player._visage == 3156)
					_sceneMode = 56;
				else
					_sceneMode = 55;
				break;
			case 1:
				if (R2_GLOBALS._player._visage == 3155)
					_sceneMode = 25;
				else
					_sceneMode = 20;
				break;
			case 2:
				if (R2_GLOBALS._player._visage == 3156)
					_sceneMode = 91;
				else
					_sceneMode = 90;
				break;
			case 3:
				if (R2_GLOBALS._player._visage == 3156)
					_sceneMode = 121;
				else
					_sceneMode = 120;
				break;
			default:
				break;
			}
			R2_GLOBALS._player.disableControl();
			_field412 = 2;
			signal();
		}
		break;
	case 2:
		if ( ((_object1.sub51AF8(Common::Point(140, 110)) > 36) || (_object1.sub51AF8(Common::Point(178, 110)) > 36)) 
			&& ( ((R2_GLOBALS._v56AA2 == 17) && (R2_GLOBALS._v56AA4 == 5) && (_field418 != 3)) 
				|| ((R2_GLOBALS._v56AA2 == 41) && (R2_GLOBALS._v56AA4 == 21)) )
				)	{
			R2_GLOBALS._player.disableControl();
			_sceneMode = 1203;
			setAction(&_sequenceManager, this, 1203, &_actor1, NULL);
		} else if (_object1.sub51AF8(Common::Point(160, 110)) == 36) {
			switch (_field412 - 1) {
			case 0:
				if (R2_GLOBALS._player._visage == 3156)
					_sceneMode = 51;
				else
					_sceneMode = 50;
				break;
			case 1:
				if (R2_GLOBALS._player._visage == 3156)
					_sceneMode = 81;
				else
					_sceneMode = 80;
				break;
			case 2:
				if (R2_GLOBALS._player._visage == 3155)
					_sceneMode = 35;
				else
					_sceneMode = 30;
				break;
			case 3:
				if (R2_GLOBALS._player._visage == 3156)
					_sceneMode = 116;
				else
					_sceneMode = 115;
				break;
			default:
				break;
			}
			R2_GLOBALS._player.disableControl();
			_field412 = 3;
			signal();
		}
		break;
	case 3:
		if ( ((_object1.sub51AF8(Common::Point(140, 30)) > 36) || (_object1.sub51AF8(Common::Point(178, 30)) > 36)) 
			&& ( ((R2_GLOBALS._v56AA2 == 17) && (R2_GLOBALS._v56AA4 == 9) && (_field418 != 3)) 
				|| ((R2_GLOBALS._v56AA2 == 35) && (R2_GLOBALS._v56AA4 == 17)) )
				)	{
			R2_GLOBALS._player.disableControl();
			_sceneMode = 1202;
			setAction(&_sequenceManager, this, 1202, &_actor1, NULL);
		} else if (_object1.sub51AF8(Common::Point(160, 30)) == 36) {
			switch (_field412 - 1) {
			case 0:
				if (R2_GLOBALS._player._visage == 3156)
					_sceneMode = 61;
				else
					_sceneMode = 60;
				break;
			case 1:
				if (R2_GLOBALS._player._visage == 3156)
					_sceneMode = 71;
				else
					_sceneMode = 70;
				break;
			case 2:
				if (R2_GLOBALS._player._visage == 3156)
					_sceneMode = 96;
				else
					_sceneMode = 95;
				break;
			case 3:
				if (R2_GLOBALS._player._visage == 3155)
					_sceneMode = 45;
				else
					_sceneMode = 40;
				break;
			default:
				_sceneMode = 1;
				R2_GLOBALS._player.setup(3156, 4, 6);
				break;
			}
			R2_GLOBALS._player.disableControl();
			_field412 = 4;
			signal();
		}
		break;
	default:
		break;
	}
}
Example #29
0
int main() {
  /// Sets up exception handling
  signal(SIGFPE, FPE_ExceptionHandler); 


  bool gaugeUnification = true, ewsbBCscale = false;

  /// Do we include 2-loop RGEs of *all* scalar masses and A-terms, or only the
  /// scalar mass Higgs parameters? (Other quantities all 2-loop anyway): the
  /// default in SOFTSUSY 3 is to include all 2-loop terms, except for RPV,
  /// which is already slow and calculated to less accuracy than the R-parity
  /// conserving version
  INCLUDE_2_LOOP_SCALAR_CORRECTIONS = false;

  /// Sets format of output: 6 decimal places
  outputCharacteristics(6);

  /// Header  
  cerr << "SOFTSUSY" << SOFTSUSY_VERSION 
       << " Ben Allanach, Markus Bernhardt 2009\n";
  cerr << "If you use SOFTSUSY, please refer to B.C. Allanach, ";
  cerr << "Comput. Phys. Commun. 143 (2002) 305, hep-ph/0104145;\n";
  cerr << "For RPV aspects, B.C. Allanach and M.A. Bernhardt, ";
  cerr << "Comp. Phys. Commun. 181 (2010) 232, ";
  cerr << "arXiv:0903.1805.\n";

  /// "try" catches errors in main program and prints them out
  try {

    /// Contains default quark and lepton masses and gauge coupling
    /// information 
    QedQcd oneset;      ///< See "lowe.h" for default parameter definitions 
    oneset.toMz();      ///< Runs SM fermion masses to MZ
    
    /// Print out the Standard Model data being used, as well as quark mixing
    /// assumption and the numerical accuracy of the solution
    cerr << "Low energy data in SOFTSUSY: MIXING=" << MIXING << " TOLERANCE=" 
         << TOLERANCE << endl << oneset << endl;
    /// set parameters
    double tanb = 10.;
    int sgnMu = 1;
    double mgutGuess = 2.e16; 
    double a0 = 0.0, m12 = 500.0, m0 = 125.0; 
    
    /// number of points for scan
    const int numPoints = 20; 
    
    /// parameter region
    double Start = 0. , End = 0.4;
    
    DoubleVector pars(3);
    /// set basic entries in pars
    pars(1) = m0; pars(2) = m12; pars(3) = a0;
      
    cout << "# l''_{323}(M_X) m_stop_R     # Problem flag" << endl;
    /// loop over parameter space region
    int ii; for (ii=0; ii<=numPoints; ii++){
      double lambda = Start + ((End - Start) / double(numPoints) * double(ii));
      
      /// define rpvSoftsusy object
      RpvSoftsusy kw;
      
      /// set lambda coupling at mgut
      kw.setLamPrimePrime(3, 2, 3, lambda); 
      
      /// output parameters into double vector pars used by lowOrg
      kw.rpvDisplay(pars);
      
      /// generate spectrum in RpvSoftsusy object kw
      kw.lowOrg(rpvSugraBcs, mgutGuess, pars, sgnMu,
                tanb, oneset, gaugeUnification, ewsbBCscale);
      
      /// outputs for this scan
      cout << lambda << "  " << kw.displayPhys().mu(2, 3) << " # " 
           << kw.displayProblem() << endl;
    }
  }
  catch(const string & a) {
    cout << a; return -1;
  }
  catch(const char *a) {
    printf("%s", a); return -1;
  }
  return 0;
}
Example #30
0
int
main(int argc, char *argv[])
{
#ifdef __FreeBSD__
	FILE *fpid = NULL;
#endif	
	fd_set *fdsr = NULL, *fdsw = NULL;
	struct sockaddr_in sin;
	struct sockaddr_in lin;
	int ch, s, s2, conflisten = 0, syncfd = 0, i, omax = 0, one = 1;
	socklen_t sinlen;
	u_short port;
	struct servent *ent;
	struct rlimit rlp;
	char *bind_address = NULL;
	const char *errstr;
	char *sync_iface = NULL;
	char *sync_baddr = NULL;

	tzset();
	openlog_r("spamd", LOG_PID | LOG_NDELAY, LOG_DAEMON, &sdata);

	if ((ent = getservbyname("spamd", "tcp")) == NULL)
		errx(1, "Can't find service \"spamd\" in /etc/services");
	port = ntohs(ent->s_port);
	if ((ent = getservbyname("spamd-cfg", "tcp")) == NULL)
		errx(1, "Can't find service \"spamd-cfg\" in /etc/services");
	cfg_port = ntohs(ent->s_port);
	if ((ent = getservbyname("spamd-sync", "udp")) == NULL)
		errx(1, "Can't find service \"spamd-sync\" in /etc/services");
	sync_port = ntohs(ent->s_port);

	if (gethostname(hostname, sizeof hostname) == -1)
		err(1, "gethostname");
	maxfiles = get_maxfiles();
	if (maxcon > maxfiles)
		maxcon = maxfiles;
	if (maxblack > maxfiles)
		maxblack = maxfiles;
	while ((ch =
#ifndef __FreeBSD__
	    getopt(argc, argv, "45l:c:B:p:bdG:h:s:S:M:n:vw:y:Y:")) != -1) {
#else
	    getopt(argc, argv, "45l:c:B:p:bdG:h:s:S:M:n:vw:y:Y:t:m:")) != -1) {
#endif
		switch (ch) {
		case '4':
			nreply = "450";
			break;
		case '5':
			nreply = "550";
			break;
		case 'l':
			bind_address = optarg;
			break;
		case 'B':
			i = atoi(optarg);
			maxblack = i;
			break;
		case 'c':
			i = atoi(optarg);
			if (i > maxfiles) {
				fprintf(stderr,
				    "%d > system max of %d connections\n",
				    i, maxfiles);
				usage();
			}
			maxcon = i;
			break;
		case 'p':
			i = atoi(optarg);
			port = i;
			break;
		case 'd':
			debug = 1;
			break;
		case 'b':
			greylist = 0;
			break;
		case 'G':
			if (sscanf(optarg, "%d:%d:%d", &passtime, &greyexp,
			    &whiteexp) != 3)
				usage();
			/* convert to seconds from minutes */
			passtime *= 60;
			/* convert to seconds from hours */
			whiteexp *= (60 * 60);
			/* convert to seconds from hours */
			greyexp *= (60 * 60);
			break;
		case 'h':
			bzero(&hostname, sizeof(hostname));
			if (strlcpy(hostname, optarg, sizeof(hostname)) >=
			    sizeof(hostname))
				errx(1, "-h arg too long");
			break;
		case 's':
			i = atoi(optarg);
			if (i < 0 || i > 10)
				usage();
			stutter = i;
			break;
		case 'S':
			/* 
			 * strtonum is aviable with FreeBSD 6.1,
			 * for older versions we have to fallback
			 */

			i = strtonum(optarg, 0, 90, &errstr);
			if (errstr)
				usage();
			grey_stutter = i;
			break;
		case 'M':
			low_prio_mx_ip = optarg;
			break;
		case 'n':
			spamd = optarg;
			break;
		case 'v':
			verbose = 1;
			break;
		case 'w':
			window = atoi(optarg);
			if (window <= 0)
				usage();
			break;
		case 'Y':
			if (sync_addhost(optarg, sync_port) != 0)
				sync_iface = optarg;
			syncsend++;
			break;
		case 'y':
			sync_baddr = optarg;
			syncrecv++;
			break;
#ifdef __FreeBSD__
		case 't':
			ipfw_tabno = atoi(optarg);
			break;
		case 'm':
			if (strcmp(optarg, "ipfw") == 0)
				use_pf=0;
			break;
#endif
		default:
			usage();
			break;
		}
	}

	setproctitle("[priv]%s%s",
	    greylist ? " (greylist)" : "",
	    (syncrecv || syncsend) ? " (sync)" : "");

	if (!greylist)
		maxblack = maxcon;
	else if (maxblack > maxcon)
		usage();

	rlp.rlim_cur = rlp.rlim_max = maxcon + 15;
	if (setrlimit(RLIMIT_NOFILE, &rlp) == -1)
		err(1, "setrlimit");

	con = calloc(maxcon, sizeof(*con));
	if (con == NULL)
		err(1, "calloc");

	con->obuf = malloc(8192);

	if (con->obuf == NULL)
		err(1, "malloc");
	con->osize = 8192;

	for (i = 0; i < maxcon; i++)
		con[i].fd = -1;

	signal(SIGPIPE, SIG_IGN);

	s = socket(AF_INET, SOCK_STREAM, 0);
	if (s == -1)
		err(1, "socket");

	if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &one,
	    sizeof(one)) == -1)
		return (-1);

	conflisten = socket(AF_INET, SOCK_STREAM, 0);
	if (conflisten == -1)
		err(1, "socket");

	if (setsockopt(conflisten, SOL_SOCKET, SO_REUSEADDR, &one,
	    sizeof(one)) == -1)
		return (-1);

	memset(&sin, 0, sizeof sin);
	sin.sin_len = sizeof(sin);
	if (bind_address) {
		if (inet_pton(AF_INET, bind_address, &sin.sin_addr) != 1)
			err(1, "inet_pton");
	} else
		sin.sin_addr.s_addr = htonl(INADDR_ANY);
	sin.sin_family = AF_INET;
	sin.sin_port = htons(port);

	if (bind(s, (struct sockaddr *)&sin, sizeof sin) == -1)
		err(1, "bind");

	memset(&lin, 0, sizeof sin);
	lin.sin_len = sizeof(sin);
	lin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
	lin.sin_family = AF_INET;
	lin.sin_port = htons(cfg_port);

	if (bind(conflisten, (struct sockaddr *)&lin, sizeof lin) == -1)
		err(1, "bind local");

	if (syncsend || syncrecv) {
		syncfd = sync_init(sync_iface, sync_baddr, sync_port);
		if (syncfd == -1)
			err(1, "sync init");
	}

	pw = getpwnam("_spamd");
	if (!pw)
		pw = getpwnam("nobody");

#ifdef __FreeBSD__
	/* open the pid file just before daemon */
	fpid = fopen(pid_file, "w");
	if (fpid == NULL) {
		syslog(LOG_ERR, "exiting (couldn't create pid file %s)", 
			pid_file);
		err(1, "couldn't create pid file \"%s\"", pid_file);
	}
#endif	

	if (debug == 0) {
		if (daemon(1, 1) == -1)
			err(1, "daemon");
	}

	if (greylist) {
#ifdef __FreeBSD__
		if(use_pf){
#endif			
			pfdev = open("/dev/pf", O_RDWR);
			if (pfdev == -1) {
				syslog_r(LOG_ERR, &sdata, "open /dev/pf: %m");
				exit(1);
			}
#ifdef __FreeBSD__
		} 	
#endif

		maxblack = (maxblack >= maxcon) ? maxcon - 100 : maxblack;
		if (maxblack < 0)
			maxblack = 0;

		/* open pipe to talk to greylister */
		if (pipe(greypipe) == -1) {
			syslog(LOG_ERR, "pipe (%m)");
			exit(1);
		}
		/* open pipe to recieve spamtrap configs */
		if (pipe(trappipe) == -1) {
			syslog(LOG_ERR, "pipe (%m)");
			exit(1);
		}
		jail_pid = fork();
		switch (jail_pid) {
		case -1:
			syslog(LOG_ERR, "fork (%m)");
			exit(1);
		case 0:
			/* child - continue */
			signal(SIGPIPE, SIG_IGN);
			grey = fdopen(greypipe[1], "w");
			if (grey == NULL) {
				syslog(LOG_ERR, "fdopen (%m)");
				_exit(1);
			}
			close(greypipe[0]);
			trapfd = trappipe[0];
			trapcfg = fdopen(trappipe[0], "r");
			if (trapcfg == NULL) {
				syslog(LOG_ERR, "fdopen (%m)");
				_exit(1);
			}
			close(trappipe[1]);
			goto jail;
		}
		/* parent - run greylister */
		grey = fdopen(greypipe[0], "r");
		if (grey == NULL) {
			syslog(LOG_ERR, "fdopen (%m)");
			exit(1);
		}
		close(greypipe[1]);
		trapcfg = fdopen(trappipe[1], "w");
		if (trapcfg == NULL) {
			syslog(LOG_ERR, "fdopen (%m)");
			exit(1);
		}
		close(trappipe[0]);
		return (greywatcher());
		/* NOTREACHED */
	}

jail:
#ifdef __FreeBSD__
	/* after switch user and daemon write and close the pid file */
	if (fpid) {
		fprintf(fpid, "%ld\n", (long) getpid());
		if (fclose(fpid) == EOF) {
			syslog(LOG_ERR, "exiting (couldn't close pid file %s)", 
				pid_file);
			exit(1);
		}
	}
#endif	

	if (chroot("/var/empty") == -1 || chdir("/") == -1) {
		syslog(LOG_ERR, "cannot chdir to /var/empty.");
		exit(1);
	}

	if (pw)
		if (setgroups(1, &pw->pw_gid) ||
		    setresgid(pw->pw_gid, pw->pw_gid, pw->pw_gid) ||
		    setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid))
			err(1, "failed to drop privs");

	if (listen(s, 10) == -1)
		err(1, "listen");

	if (listen(conflisten, 10) == -1)
		err(1, "listen");

	if (debug != 0)
		printf("listening for incoming connections.\n");
	syslog_r(LOG_WARNING, &sdata, "listening for incoming connections.");

	while (1) {
		struct timeval tv, *tvp;
		int max, n;
		int writers;

		max = MAX(s, conflisten);
		if (syncrecv)
			max = MAX(max, syncfd);
		max = MAX(max, conffd);
		max = MAX(max, trapfd);

		time(&t);
		for (i = 0; i < maxcon; i++)
			if (con[i].fd != -1)
				max = MAX(max, con[i].fd);

		if (max > omax) {
			free(fdsr);
			fdsr = NULL;
			free(fdsw);
			fdsw = NULL;
			fdsr = (fd_set *)calloc(howmany(max+1, NFDBITS),
			    sizeof(fd_mask));
			if (fdsr == NULL)
				err(1, "calloc");
			fdsw = (fd_set *)calloc(howmany(max+1, NFDBITS),
			    sizeof(fd_mask));
			if (fdsw == NULL)
				err(1, "calloc");
			omax = max;
		} else {
			memset(fdsr, 0, howmany(max+1, NFDBITS) *
			    sizeof(fd_mask));
			memset(fdsw, 0, howmany(max+1, NFDBITS) *
			    sizeof(fd_mask));
		}

		writers = 0;
		for (i = 0; i < maxcon; i++) {
			if (con[i].fd != -1 && con[i].r) {
				if (con[i].r + MAXTIME <= t) {
					closecon(&con[i]);
					continue;
				}
				FD_SET(con[i].fd, fdsr);
			}
			if (con[i].fd != -1 && con[i].w) {
				if (con[i].w + MAXTIME <= t) {
					closecon(&con[i]);
					continue;
				}
				if (con[i].w <= t)
					FD_SET(con[i].fd, fdsw);
				writers = 1;
			}
		}
		FD_SET(s, fdsr);

		/* only one active config conn at a time */
		if (conffd == -1)
			FD_SET(conflisten, fdsr);
		else
			FD_SET(conffd, fdsr);
		if (trapfd != -1)
			FD_SET(trapfd, fdsr);
		if (syncrecv)
			FD_SET(syncfd, fdsr);

		if (writers == 0) {
			tvp = NULL;
		} else {
			tv.tv_sec = 1;
			tv.tv_usec = 0;
			tvp = &tv;
		}

		n = select(max+1, fdsr, fdsw, NULL, tvp);
		if (n == -1) {
			if (errno != EINTR)
				err(1, "select");
			continue;
		}
		if (n == 0)
			continue;

		for (i = 0; i < maxcon; i++) {
			if (con[i].fd != -1 && FD_ISSET(con[i].fd, fdsr))
				handler(&con[i]);
			if (con[i].fd != -1 && FD_ISSET(con[i].fd, fdsw))
				handlew(&con[i], clients + 5 < maxcon);
		}
		if (FD_ISSET(s, fdsr)) {
			sinlen = sizeof(sin);
			s2 = accept(s, (struct sockaddr *)&sin, &sinlen);
			if (s2 == -1)
				/* accept failed, they may try again */
				continue;
			for (i = 0; i < maxcon; i++)
				if (con[i].fd == -1)
					break;
			if (i == maxcon)
				close(s2);
			else {
				initcon(&con[i], s2, (struct sockaddr *)&sin);
				syslog_r(LOG_INFO, &sdata,
				    "%s: connected (%d/%d)%s%s",
				    con[i].addr, clients, blackcount,
				    ((con[i].lists == NULL) ? "" :
				    ", lists:"),
				    ((con[i].lists == NULL) ? "":
				    con[i].lists));
			}
		}
		if (FD_ISSET(conflisten, fdsr)) {
			sinlen = sizeof(lin);
			conffd = accept(conflisten, (struct sockaddr *)&lin,
			    &sinlen);
			if (conffd == -1)
				/* accept failed, they may try again */
				continue;
			else if (ntohs(lin.sin_port) >= IPPORT_RESERVED) {
				close(conffd);
				conffd = -1;
			}
		}
		if (conffd != -1 && FD_ISSET(conffd, fdsr))
			do_config();
		if (trapfd != -1 && FD_ISSET(trapfd, fdsr))
			read_configline(trapcfg);
		if (syncrecv && FD_ISSET(syncfd, fdsr))
			sync_recv();
	}
	exit(1);
}