Esempio n. 1
0
void init_lirc (void)
{
    int flags;

    if ((lirc_fd = lirc_init ("audacious", 1)) == -1)
    {
        fprintf (stderr, _("%s: could not init LIRC support\n"), plugin_name);
        return;
    }
    if (lirc_readconfig (NULL, &config, NULL) == -1)
    {
        lirc_deinit ();
        fprintf (stderr,
                 _("%s: could not read LIRC config file\n"
                   "%s: please read the documentation of LIRC\n"
                   "%s: how to create a proper config file\n"),
                 plugin_name, plugin_name, plugin_name);
        return;
    }

    input_tag =
        g_io_add_watch (g_io_channel_unix_new (lirc_fd), G_IO_IN,
                        lirc_input_callback, NULL);

    fcntl (lirc_fd, F_SETOWN, getpid ());
    flags = fcntl (lirc_fd, F_GETFL, 0);
    if (flags != -1)
    {
        fcntl (lirc_fd, F_SETFL, flags | O_NONBLOCK);
    }
    fflush (stdout);
}
Esempio n. 2
0
int
mp_input_lirc_init(void) {
  int lirc_sock;
  int mode;

  mp_msg(MSGT_LIRC, MSGL_V, "Setting up LIRC support...\n");
  if((lirc_sock=lirc_init("mplayer",1))==-1){
    mp_msg(MSGT_LIRC,MSGL_ERR,MSGTR_LIRCopenfailed);
    return -1;
  }

  mode = fcntl(lirc_sock, F_GETFL);
  if (mode < 0 || fcntl(lirc_sock, F_SETFL, mode | O_NONBLOCK) < 0) {
    mp_msg(MSGT_LIRC, MSGL_ERR, "setting non-blocking mode failed: %s\n",
	strerror(errno));
    lirc_deinit();
    return -1;
  }

  if(lirc_readconfig( lirc_configfile,&lirc_config,NULL )!=0 ){
    mp_msg(MSGT_LIRC,MSGL_ERR,MSGTR_LIRCcfgerr,
		    lirc_configfile == NULL ? "~/.lircrc" : lirc_configfile);
    lirc_deinit();
    return -1;
  }

  return lirc_sock;
}
Esempio n. 3
0
void layout_image_lirc_init(LayoutWindow *lw)
{
    gint flags;
    gboolean lirc_verbose = (get_debug_level() >= 2);

    lirc_fd = lirc_init(GQ_APPNAME_LC, lirc_verbose);
    if (lirc_fd == -1)
    {
        DEBUG_1("Initializing LIRC... failed");
        return;
    }

    DEBUG_1("Initializing LIRC... OK");
    if (lirc_readconfig(NULL, &config, NULL) == -1)
    {
        lirc_deinit();

        g_fprintf(stderr,
                  _("could not read LIRC config file\n"
                    "please read the documentation of LIRC to \n"
                    "know how to create a proper config file\n"));
        fflush(stderr);

        DEBUG_1("Failed to read LIRC config file");
        return;
    }
    if (lirc_verbose) fflush(stderr);

    gio_chan = g_io_channel_unix_new(lirc_fd);
    input_tag = g_io_add_watch(gio_chan, G_IO_IN,
                               lirc_input_callback, lw);
    fcntl(lirc_fd, F_SETOWN, getpid());
    flags = fcntl(lirc_fd, F_GETFL, 0);
    if (flags != -1) fcntl(lirc_fd, F_SETFL, flags|O_NONBLOCK);
}
Esempio n. 4
0
int LircClient::Init(const QString &config_file, const QString &program,
                        bool ignoreExtApp)
{
    int fd;

    /* Connect the unix socket */
    fd = lirc_init((char *)program.latin1(), 1);
    if (fd == -1)
    {
        VERBOSE(VB_IMPORTANT,
                QString("lirc_init failed for %1, see preceding messages")
                .arg(program));
        return -1;
    }

    /* parse the config file */
    if (lirc_readconfig((char *)config_file.latin1(), &lircConfig, NULL))
    {
        VERBOSE(VB_IMPORTANT,
                QString("Failed to read lirc config %1 for %2")
                .arg(config_file).arg(program));
        lirc_deinit();
        return -1;
    }

    if (!ignoreExtApp)
        external_app = gContext->GetSetting("LircKeyPressedApp", "");

    VERBOSE(VB_GENERAL,
            QString("lirc init success using configuration file: %1")
            .arg(config_file));

    return 0;
}
Esempio n. 5
0
File: lirc.c Progetto: kax4/mpv
int
mp_input_lirc_init(void) {
  int lirc_sock;
  int mode;

  mp_tmsg(MSGT_LIRC,MSGL_V,"Setting up LIRC support...\n");
  if((lirc_sock=lirc_init("mpv",0))==-1){
    mp_tmsg(MSGT_LIRC,MSGL_V,"Failed to open LIRC support. You will not be able to use your remote control.\n");
    return -1;
  }

  mode = fcntl(lirc_sock, F_GETFL);
  if (mode < 0 || fcntl(lirc_sock, F_SETFL, mode | O_NONBLOCK) < 0) {
    mp_msg(MSGT_LIRC, MSGL_ERR, "setting non-blocking mode failed: %s\n",
	strerror(errno));
    lirc_deinit();
    return -1;
  }

  if(lirc_readconfig( lirc_configfile,&lirc_config,NULL )!=0 ){
    mp_tmsg(MSGT_LIRC,MSGL_ERR,"Failed to read LIRC config file %s.\n",
		    lirc_configfile == NULL ? "~/.lircrc" : lirc_configfile);
    lirc_deinit();
    return -1;
  }

  return lirc_sock;
}
Esempio n. 6
0
void CLirc::Process()
{
  m_profileId = CServiceBroker::GetProfileManager().GetCurrentProfileId();
  m_irTranslator.Load("Lircmap.xml");

  // make sure work-around (CheckDaemon) uses the same socket path as lirc_init
  const char* socket_path = getenv("LIRC_SOCKET_PATH");
  socket_path = socket_path ? socket_path : "/var/run/lirc/lircd";
  setenv("LIRC_SOCKET_PATH", socket_path, 0);

  while (!m_bStop)
  {
    {
      CSingleLock lock(m_critSection);

      // lirc_client is buggy because it does not close socket, if connect fails
      // work around by checking if daemon is running before calling lirc_init
      if (!CheckDaemon())
      {
        CSingleExit lock(m_critSection);
        Sleep(1000);
        continue;
      }

      m_fd = lirc_init(const_cast<char*>("kodi"), 0);
      if (m_fd <= 0)
      {
        CSingleExit lock(m_critSection);
        Sleep(1000);
        continue;
      }
    }

    char *code;
    while (!m_bStop)
    {
      int ret = lirc_nextcode(&code);
      if (ret < 0)
      {
        lirc_deinit();
        Sleep(1000);
        break;
      }
      if (code != nullptr)
      {
        if (m_profileId != CServiceBroker::GetProfileManager().GetCurrentProfileId())
        {
          m_profileId = CServiceBroker::GetProfileManager().GetCurrentProfileId();
          m_irTranslator.Load("Lircmap.xml");
        }
        ProcessCode(code);
        free(code);
      }
    }
  }

  lirc_deinit();
}
Esempio n. 7
0
int
main (int argc, const char *argv[]) {
  int fd;
  struct lirc_config *config;
  char *code;

  if ((fd = lirc_init("lirc", 1)) == -1) {
    fprintf(stderr, "cannot init lirc\n");
    exit(EXIT_FAILURE);
  }

  fprintf(stdout, "LIRC FD = %d\n", fd);
  fflush(stdout);

#if 0 // XXX test non-block socket (for integration with tcdr)
  if (fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) | O_NONBLOCK) == -1) {
    fprintf(stderr, "cannot make socket as non block\n");
    exit(EXIT_FAILURE);
  }
#endif

  if (lirc_readconfig(NULL, &config, NULL) == 0) {
    while (lirc_nextcode(&code) == 0) {
      if (!code)
        continue;

      if (strstr(code, "KEY_MENU")) {
        fprintf(stdout, "MENU\n");
        fflush(stdout);
      } else if (strstr(code, "KEY_PLAYPAUSE")) {
        fprintf(stdout, "PLAY\n");
        fflush(stdout);
      } else if (strstr(code, "KEY_FORWARD")) {
        fprintf(stdout, "FWRD\n");
        fflush(stdout);
      } else if (strstr(code, "KEY_REWIND")) {
        fprintf(stdout, "RWND\n");
        fflush(stdout);
      } else if (strstr(code, "KEY_VOLUMEUP")) {
        fprintf(stdout, "VLUP\n");
        fflush(stdout);
      } else if (strstr(code, "KEY_VOLUMEDOWN")) {
        fprintf(stdout, "VLDN\n");
        fflush(stdout);
      } else {
        fprintf(stderr, "UNKN\n");
      }

      free(code);
    }

    lirc_freeconfig(config);
  }

  lirc_deinit();
  
  return 0;
}
Esempio n. 8
0
int pa__init(pa_module*m) {
    pa_modargs *ma = NULL;
    struct userdata *u;
    pa_volume_t volume_limit = PA_CLAMP_VOLUME(PA_VOLUME_NORM*3/2);
    pa_volume_t volume_step = PA_VOLUME_NORM/20;

    pa_assert(m);

    if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
        pa_log("Failed to parse module arguments");
        goto fail;
    }

    if (pa_modargs_get_value_u32(ma, "volume_limit", &volume_limit) < 0) {
        pa_log("Failed to parse volume limit");
        goto fail;
    }

    if (pa_modargs_get_value_u32(ma, "volume_step", &volume_step) < 0) {
        pa_log("Failed to parse volume step");
        goto fail;
    }

    m->userdata = u = pa_xnew(struct userdata, 1);
    u->module = m;
    u->io = NULL;
    u->config = NULL;
    u->sink_name = pa_xstrdup(pa_modargs_get_value(ma, "sink", NULL));
    u->lirc_fd = -1;
    u->mute_toggle_save = 0;
    u->volume_limit = PA_CLAMP_VOLUME(volume_limit);
    u->volume_step = PA_CLAMP_VOLUME(volume_step);

    if ((u->lirc_fd = lirc_init((char*) pa_modargs_get_value(ma, "appname", "pulseaudio"), 1)) < 0) {
        pa_log("lirc_init() failed.");
        goto fail;
    }

    if (lirc_readconfig((char*) pa_modargs_get_value(ma, "config", NULL), &u->config, NULL) < 0) {
        pa_log("lirc_readconfig() failed.");
        goto fail;
    }

    u->io = m->core->mainloop->io_new(m->core->mainloop, u->lirc_fd, PA_IO_EVENT_INPUT|PA_IO_EVENT_HANGUP, io_callback, u);

    pa_modargs_free(ma);

    return 0;

fail:

    if (ma)
        pa_modargs_free(ma);

    pa__done(m);
    return -1;
}
Esempio n. 9
0
void lircStart(void)
{
    if((g_lircfd = lirc_init("mupen64plus", 1)) != -1)
    {
        g_config = NULL;
        if(lirc_readconfig(NULL, &g_config, NULL) == 0)
            DebugMessage(M64MSG_INFO, "LIRC input system started successfully");
        else
            DebugMessage(M64MSG_WARNING, "LIRC disabled: Error reading lircrc!");
    }
    else
        DebugMessage(M64MSG_WARNING, "LIRC disabled: Error contacting daemon!");
}
Esempio n. 10
0
static void *thread_func(void *arg)
{
	struct lirc_config *config;
	int    sock, flags;

	if ((sock = lirc_init("gmu", 1)) != -1) {
		fcntl(sock, F_SETOWN, getpid());
		flags = fcntl(sock, F_GETFL, 0);
		if (flags != -1) fcntl(sock, F_SETFL, flags|O_NONBLOCK);
		if (lirc_readconfig(NULL, &config, NULL) == 0) {
			char *code, *c;
			int   ret = 0;

			while (run && lirc_nextcode(&code) == 0) {
				if (code != NULL) {
					if ((ret = lirc_code2char(config, code, &c)) == 0 && c != NULL) {
						wdprintf(V_DEBUG, "lirc_frontend", "Got button press.\n");
						if (strcmp(c, "play") == 0)
							gmu_core_play();					
						else if (strcmp(c, "pause") == 0)
							gmu_core_pause();
						else if (strcmp(c, "stop") == 0)
							gmu_core_stop();
						else if (strcmp(c, "toggle_pause") == 0)
							gmu_core_play_pause();
						else if (strcmp(c, "toggle_play_pause") == 0)
							gmu_core_play_pause();
						else if (strcmp(c, "next") == 0)
							gmu_core_next();				
						else if (strcmp(c, "prev") == 0)
							gmu_core_previous();
						else if (strcmp(c, "volume_up") == 0)
							gmu_core_set_volume(gmu_core_get_volume()+1);
						else if (strcmp(c, "volume_down") == 0)
							gmu_core_set_volume(gmu_core_get_volume()-1);
						else
							wdprintf(V_WARNING, "lirc_frontend", "Unknown command: %s\n", c);
						c = NULL;
					}
				}
				usleep(400);
				free(code);
				if (ret == -1) break;
			}
			wdprintf(V_INFO, "lirc_frontend", "Exitting.\n");
			lirc_freeconfig(config);
		}
		lirc_deinit();
	}
	return NULL;
}
Esempio n. 11
0
/* Try to open a connection to lircd if suppor is enabled
** if it fails, disable support, print a message and continue
*/
void init_lirc(void) {
    if (using_lirc) {
        using_lirc = false;
        if ((lirc_fd = lirc_init("squeezeslave",1)) > 0) {
            if (lirc_readconfig(lircrc, &lircconfig, NULL)==0) {
                using_lirc = true;
                setNonblocking(lcd_fd);
            } else {
                using_lirc = true;
                close_lirc();
            }
        }
        if (!using_lirc ) fprintf(stderr, "Failed to init LIRC\n");
    }
}
Esempio n. 12
0
master_irda::master_irda(thread_data *my_data)
{
    buttonTimer = millis();
    buttonMENU = 0;
      my_data2 = my_data;

    //Initiate LIRC. Exit on failure
    if(lirc_init("lirc",1)==-1)
        exit(EXIT_FAILURE);
    std::cout << " jestem po uruchominiu lirc \n";

    //// tu chyba sa glupoty  zle


}
Esempio n. 13
0
static struct lirc_config *
mex_lirc_init (const gchar *name)
{
  int lirc_fd, res;
  gchar *tmp;

  lirc_fd = lirc_init ((char *)name, 1);

  if (lirc_fd == -1)
    g_warning (G_STRLOC ": LIRC initialisation failed");
  else
    {
      struct lirc_config *config = NULL;

      /* Load the default config */
      tmp = g_build_filename (mex_get_data_dir (), "mex-lircrc", NULL);
      res = lirc_readconfig (tmp, &config, NULL);
      g_free (tmp);

      if (res == 0)
        {
          int flags;
          GIOChannel *channel;

          /* Set non-blocking flag */
          flags = fcntl (lirc_fd, F_GETFL);
          fcntl (lirc_fd, F_SETFL, flags | O_NONBLOCK);

          /* Create IOChannel to do non-blocking reads */
          channel = g_io_channel_unix_new (lirc_fd);
          g_io_add_watch (channel,
                          G_IO_IN | G_IO_PRI | G_IO_ERR |
                          G_IO_NVAL | G_IO_HUP,
                          (GIOFunc)mex_lirc_read_cb,
                          config);

          return config;
        }
      else
        {
          g_warning (G_STRLOC ": Error reading LIRC config");
          lirc_deinit ();
        }
    }

  return NULL;
}
Esempio n. 14
0
File: lirc.c Progetto: blinry/vlc
/*****************************************************************************
 * Open: initialize interface
 *****************************************************************************/
static int Open( vlc_object_t *p_this )
{
    intf_thread_t *p_intf = (intf_thread_t *)p_this;
    intf_sys_t *p_sys;

    /* Allocate instance and initialize some members */
    p_intf->p_sys = p_sys = malloc( sizeof( intf_sys_t ) );
    if( p_sys == NULL )
        return VLC_ENOMEM;

    p_sys->i_fd = lirc_init( "vlc", 1 );
    if( p_sys->i_fd == -1 )
    {
        msg_Err( p_intf, "lirc initialisation failed" );
        goto error;
    }

    /* We want polling */
    fcntl( p_sys->i_fd, F_SETFL, fcntl( p_sys->i_fd, F_GETFL ) | O_NONBLOCK );

    /* Read the configuration file */
    char *psz_file = var_InheritString( p_intf, "lirc-file" );
    int val = lirc_readconfig( psz_file, &p_sys->config, NULL );
    free( psz_file );
    if( val != 0 )
    {
        msg_Err( p_intf, "failure while reading lirc config" );
        lirc_deinit();
        goto error;
    }

    if( vlc_clone( &p_sys->thread, Run, p_intf, VLC_THREAD_PRIORITY_LOW ) )
    {
        lirc_freeconfig( p_sys->config );
        lirc_deinit();
        goto error;
    }

    return VLC_SUCCESS;

error:
    free( p_sys );
    return VLC_EGENERIC;
}
Esempio n. 15
0
File: lirc.cpp Progetto: 63n/bino
void lircclient::init()
{
    if (!_initialized)
    {
        int socket_flags;
        _socket = lirc_init(const_cast<char *>(_client_name.c_str()), msg::level() == msg::DBG ? 1 : 0);
        if (_socket == -1)
        {
            throw exc(_("Cannot initialize LIRC."));
        }
        if ((socket_flags = fcntl(_socket, F_GETFL)) < 0
                || fcntl(_socket, F_SETFL, socket_flags | O_NONBLOCK) < 0)
        {
            lirc_deinit();
            throw exc(_("Cannot set LIRC socket properties."));
        }
        if (_conf_files.size() == 0)
        {
            if (lirc_readconfig(NULL, &_config, NULL) != 0)
            {
                lirc_deinit();
                throw exc(_("Cannot read LIRC default configuration."));
            }
        }
        else
        {
            _config = NULL;
            for (size_t i = 0; i < _conf_files.size(); i++)
            {
                if (lirc_readconfig(const_cast<char *>(_conf_files[i].c_str()), &_config, NULL) != 0)
                {
                    if (_config)
                    {
                        lirc_freeconfig(_config);
                    }
                    lirc_deinit();
                    throw exc(str::asprintf(_("Cannot read LIRC configuration file %s."), _conf_files[i].c_str()));
                }
            }
        }
        _initialized = true;
    }
}
Esempio n. 16
0
static void
impl_activate (PeasActivatable *bplugin)
{
	int fd;
	char *path;
	RBLircPlugin *plugin = RB_LIRC_PLUGIN (bplugin);
	RBShell *shell;

	g_object_get (plugin, "object", &shell, NULL);

	g_object_get (shell, "shell-player", &plugin->shell_player, NULL);

	rb_debug ("Activating lirc plugin");

	fd = lirc_init ("Rhythmbox", 1);
	if (fd < 0) {
		rb_debug ("Couldn't initialize lirc");
		g_object_unref (shell);
		return;
	}

	/* Load the default Rhythmbox setup */
	path = rb_find_plugin_data_file (G_OBJECT (plugin), "rhythmbox_lirc_default");
	if (path == NULL || lirc_readconfig (path, &plugin->lirc_config, NULL) == -1) {
		g_free (path);
		close (fd);
		rb_debug ("Couldn't read lirc configuration");
		g_object_unref (shell);
		return;
	}
	g_free (path);

	lirc_readconfig (NULL, &plugin->lirc_config, NULL);

	plugin->lirc_channel = g_io_channel_unix_new (fd);
	g_io_channel_set_encoding (plugin->lirc_channel, NULL, NULL);
	g_io_channel_set_buffered (plugin->lirc_channel, FALSE);
	g_io_add_watch (plugin->lirc_channel, G_IO_IN | G_IO_ERR | G_IO_HUP,
			(GIOFunc) rb_lirc_plugin_read_code, plugin);

	g_object_unref (shell);
}
Esempio n. 17
0
File: lirc.c Progetto: naguirre/enna
static void
module_init(Enna_Module *em)
{
    struct lirc_config *config;
    int fd;

    if (!em) return;

    mod = calloc(1, sizeof(Enna_Module_Lirc));
    if (!mod) return;
    mod->em = em;
    em->mod = mod;

    // initialize lirc
    if ((fd = lirc_init("enna", 1)) == -1) // TODO need to close this? or ecore_fd_hand_del is enoght?
    {
        enna_log(ENNA_MSG_ERROR, ENNA_MODULE_NAME,
                "could not initialize LIRC support");
        return;
    }
    if (lirc_readconfig(NULL, &config, NULL) != 0)
    {
        lirc_deinit();
        enna_log(ENNA_MSG_ERROR, ENNA_MODULE_NAME,
                "could not find Lirc config file");
        return;
    }
    mod->lirc_config = config;

    // connect to the lirc socket
    fcntl(fd, F_SETFL, O_NONBLOCK);
    fcntl(fd, F_SETFD, FD_CLOEXEC);
    mod->fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ,
            _lirc_code_received, NULL, NULL, NULL);

#if 0
    // register the configuration panel
    _config_panel = enna_config_panel_register(_("Remote"), "icon/music",
                                    lirc_panel_show, lirc_panel_hide, NULL);
#endif
}
Esempio n. 18
0
/*****************************************************************************
 * Open: initialize interface
 *****************************************************************************/
static int Open( vlc_object_t *p_this )
{
    intf_thread_t *p_intf = (intf_thread_t *)p_this;
    intf_sys_t *p_sys;
    char *psz_file;

    /* Allocate instance and initialize some members */
    p_intf->p_sys = p_sys = malloc( sizeof( intf_sys_t ) );
    if( p_sys == NULL )
        return VLC_ENOMEM;

    p_intf->pf_run = Run;

    p_sys->i_fd = lirc_init( "vlc", 1 );
    if( p_sys->i_fd == -1 )
    {
        msg_Err( p_intf, "lirc initialisation failed" );
        goto exit;
    }

    /* We want polling */
    fcntl( p_sys->i_fd, F_SETFL, fcntl( p_sys->i_fd, F_GETFL ) | O_NONBLOCK );

    /* Read the configuration file */
    psz_file = var_CreateGetNonEmptyString( p_intf, "lirc-file" );
    if( lirc_readconfig( psz_file, &p_sys->config, NULL ) != 0 )
    {
        msg_Err( p_intf, "failure while reading lirc config" );
        free( psz_file );
        goto exit;
    }
    free( psz_file );

    return VLC_SUCCESS;

exit:
    if( p_sys->i_fd != -1 )
        lirc_deinit();
    free( p_sys );
    return VLC_EGENERIC;
}
Esempio n. 19
0
static gboolean
impl_activate (TotemPlugin *plugin,
	       TotemObject *totem,
	       GError **error)
{
	TotemLircPlugin *pi = TOTEM_LIRC_PLUGIN (plugin);
	char *path;
	int fd;

	pi->totem = g_object_ref (totem);

	fd = lirc_init ("Totem", 0);
	if (fd < 0) {
		g_set_error_literal (error, TOTEM_PLUGIN_ERROR, TOTEM_PLUGIN_ERROR_ACTIVATION,
                                     _("Couldn't initialize lirc."));
		return FALSE;
	}

	/* Load the default Totem setup */
	path = totem_plugin_find_file (plugin, "totem_lirc_default");
	if (path == NULL || lirc_readconfig (path, &pi->lirc_config, NULL) == -1) {
		g_free (path);
		g_set_error_literal (error, TOTEM_PLUGIN_ERROR, TOTEM_PLUGIN_ERROR_ACTIVATION,
                                     _("Couldn't read lirc configuration."));
		close (fd);
		return FALSE;
	}
	g_free (path);

	/* Load the user config, doesn't matter if it's not there */
	lirc_readconfig (NULL, &pi->lirc_config, NULL);

	pi->lirc_channel = g_io_channel_unix_new (fd);
	g_io_channel_set_encoding (pi->lirc_channel, NULL, NULL);
	g_io_channel_set_buffered (pi->lirc_channel, FALSE);
	g_io_add_watch (pi->lirc_channel, G_IO_IN | G_IO_ERR | G_IO_HUP,
			(GIOFunc) totem_lirc_read_code, pi);

	return TRUE;
}
Esempio n. 20
0
int main(int argc, char **argv)
{
		int retcode;

		/** Init **/
		if (lirc_init("lircE161",1)==-1) exit(EXIT_FAILURE); /* Init lirc_client */
		if (lirc_readconfig( lirc_configfile, &lirc_config, NULL) !=0 ){
				lirc_deinit();
				return EXIT_FAILURE;
		}

		/* Get the command to run on command_buf */
		strcpy(command_buf, getcommand(lirc_config));

		/* build up the arguments in arf_buf at every key press */
		while(1){
				retcode = getnextlircinput();
				if (retcode == LIRCE161_ERROR)
						goto out;
				if (retcode == LIRCE161_DONE) /* done, let get out and run */
						break;
		}

		/* Put the command together */
		sprintf(composite_buf, (const char *)command_buf, arg_buf);
#ifdef DEBUG
		printf("Command is %s\n", command_buf);
		printf("Arguments are %s\n", arg_buf);
		printf("Composite Command is %s\n", composite_buf);
#endif
		system(composite_buf);

		/* finish up */
out:
		lirc_freeconfig(lirc_config);
		lirc_deinit();

		return EXIT_SUCCESS;
}
Esempio n. 21
0
int lirc_fbi_init()
{
    int fd;
    if (-1 == (fd = lirc_init("fbi",debug))) {
	if (debug)
	    fprintf(stderr,"lirc: no infrared remote support available\n");
	return -1;
    }
    if (0 != lirc_readconfig(NULL,&config,NULL)) {
	config = NULL;
    }
    if (debug)
	fprintf(stderr, "lirc: ~/.lircrc file %sfound\n",
		config ? "" : "not ");
  
    fcntl(fd,F_SETFL,O_NONBLOCK);
    fcntl(fd,F_SETFD,FD_CLOEXEC);
    if (debug)
	fprintf(stderr,"lirc: init ok\n");
  
    return fd;
}
Esempio n. 22
0
/*****************************************************************************
 * Open: initialize interface
 *****************************************************************************/
static int Open( vlc_object_t *p_this )
{
    intf_thread_t *p_intf = (intf_thread_t *)p_this;
    int i_fd;

    /* Allocate instance and initialize some members */
    p_intf->p_sys = malloc( sizeof( intf_sys_t ) );
    if( p_intf->p_sys == NULL )
    {
        msg_Err( p_intf, "out of memory" );
        return 1;
    }

    p_intf->pf_run = Run;

    i_fd = lirc_init( "vlc", 1 );
    if( i_fd == -1 )
    {
        msg_Err( p_intf, "lirc_init failed" );
        free( p_intf->p_sys );
        return 1;
    }

    /* We want polling */
    fcntl( i_fd, F_SETFL, fcntl( i_fd, F_GETFL ) | O_NONBLOCK );

    if( lirc_readconfig( NULL, &p_intf->p_sys->config, NULL ) != 0 )
    {
        msg_Err( p_intf, "lirc_readconfig failed" );
        lirc_deinit();
        free( p_intf->p_sys );
        return 1;
    }

    p_intf->p_sys->p_input = NULL;

    return 0;
}
Esempio n. 23
0
static void save_list(GtkWidget *widget, GtkCList *clist)
{
   int i;
   char *data[2];
   GList *channellist = NULL;

   if (channels)
   {
      for(i=0;channels[i];i++)
         free(channels[i]);
      free(channels);
   }

   if (clist->rows)
      channels = (Channel**)malloc(sizeof(Channel*)*(clist->rows+1));
   for (i=0;i<clist->rows;i++)
   {
      channels[i] = (Channel*)malloc(sizeof(Channel));
      gtk_clist_get_text(clist, i, 0, &data[0]);
      gtk_clist_get_text(clist, i, 1, &data[1]);
      sprintf(channels[i]->name, data[0]);
      channels[i]->frequency = atoi(data[1]);
   }
   if (clist->rows)
      channels[clist->rows] = NULL;

   if (channels)
   {
      for (i=0;channels[i];i++)
         channellist = g_list_append(channellist, channels[i]->name);
   }
   if (channellist && channelcombo)
   {
      gtk_combo_set_popdown_strings (GTK_COMBO (channelcombo), channellist);
   }

#ifdef HAVE_LIRC
   for (i=0;i<RC_NUM_KEYS;i++)
      remote_buttons[i] = g_strdup(gtk_entry_get_text(GTK_ENTRY(rc_entry[i])));

   if (strcmp(lirc_dev, gtk_entry_get_text(GTK_ENTRY(lirc_device_entry))))
   {
      lirc_dev = g_strdup(gtk_entry_get_text(GTK_ENTRY(lirc_device_entry)));
      lirc_init();
   }
#endif

#ifdef OSS
   if (strcmp(mixer_dev, gtk_entry_get_text(GTK_ENTRY(mixer_device_entry))))
   {
      mixer_dev = g_strdup(gtk_entry_get_text(GTK_ENTRY(mixer_device_entry)));
      sound_init();
   }
   for (i=0;(uint)i<g_list_length(audio_src_list);i++)
   {
      if (!strcmp((char *)g_list_nth_data(audio_src_list, i),
         gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(audio_src_combo)->entry))))
      {
         audio_src = i;
      }
   }
#endif

   if (port != atoi(gtk_entry_get_text(GTK_ENTRY(v4lxv_port_entry))))
   {
      port = atoi(gtk_entry_get_text(GTK_ENTRY(v4lxv_port_entry)));
      gtk_tvplug_set(tv, "port", port);
   }

   for (i=0;(uint)i<g_list_length(GTK_TVPLUG(tv)->encoding_list);i++)
   {
      if (!strcmp(gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(v4lxv_encoding_combo)->entry)),
         (char *) g_list_nth_data(GTK_TVPLUG(tv)->encoding_list, i)))
      {
         gtk_tvplug_set(tv, "encoding", i);
         encoding_id = i;
      }
   }

   save_options();
}
Esempio n. 24
0
/* This is our thread function.  It is like main(), but for a thread*/
void *threadFunc(void *arg)
{
    struct lirc_config *config;
    int buttonTimer = millis();

    char *code;
    char *c;

    //Initiate LIRC. Exit on failure
    if(lirc_init("lirc",1)==-1)
        exit(EXIT_FAILURE);

    //Read the default LIRC config at /etc/lirc/lircd.conf This is the config for your remot$
    if(lirc_readconfig(NULL,&config,NULL)==0)
    {
        //Do stuff while LIRC socket is open 0=open -1=closed.
        while(lirc_nextcode(&code)==0)
        {
            //If code = NULL, meaning nothing was returned from LIRC socket,
            //then skip lines below and start while loop again.
            if(code==NULL) continue;
            {
                if (millis() - buttonTimer  > 400) {
                    //Check to see if the string "KEY_#" appears anywhere within the string $
                    if(strstr (code,"KEY_F")) {
                        printf("MATCH on KEY_F\n");
                        sLED(0,200,0,0);
                        buttonTimer = millis();
                    }
                    else if(strstr (code,"KEY_G")) {
                        printf("MATCH on KEY_G\n");
                        MODE = 2;
                        buttonTimer = millis();
                    }
                    else if(strstr (code,"KEY_H")) {
                        printf("MATCH on KEY_H\n");
                        MODE = 1;
                        buttonTimer = millis();
                    }
                    else if(strstr (code,"KEY_E")) {
                        printf("MATCH on KEY_E\n");
                        sLED(0,0,100,0);
                        buttonTimer = millis();
                    }
                    else if(strstr (code,"KEY_A")) {
                        printf("MATCH on KEY_A\n");
                        sLED(0,0,0,0);
                        buttonTimer = millis();
                    }

                }
            }
            //Need to free up code before the next loop
            free(code);
        }
        //Frees the data structures associated with config.
        lirc_freeconfig(config);
    }
    //lirc_deinit() closes the connection to lircd and does some internal clean-up stuff.
    lirc_deinit();
    //exit(EXIT_SUCCESS);
    return NULL;
}
Esempio n. 25
0
int main(int argc, char* argv[])
{
	char keyname[128];
	int pointer_button, pointer_x, pointer_y;
	char windowname[64];
	struct lirc_config* config;
	char* config_file = NULL;
	int c;
	unsigned int WindowID;

	while ((c = getopt_long(argc, argv, "dhV", long_options, NULL)) != EOF) {
		switch (c) {
		case 'd':
			bDaemon = 1;
			continue;
		case 'h':
			printf("Usage: %s [option]... [config file]\n"
			       "       -d --daemon     fork and run in background\n"
			       "       -h --help       display usage summary\n"
			       "       -V --version    display version\n", prog);
			return EXIT_SUCCESS;
		case 'V':
			printf("%s %s\n", prog, VERSION);
			return EXIT_SUCCESS;
		case '?':
			fprintf(stderr, "unrecognized option: -%c\n", optopt);
			fprintf(stderr, "Try `%s --help' for more information.\n", prog);
			return EXIT_FAILURE;
		}
	}

	if (argc == optind + 1) {
		config_file = argv[optind];
	} else if (argc > optind + 1) {
		fprintf(stderr, "%s: incorrect number of arguments.\n", prog);
		fprintf(stderr, "Try `%s --help' for more information.\n", prog);
		return EXIT_FAILURE;
	}

	dpy = XOpenDisplay(NULL);
	if (dpy == NULL) {
		fprintf(stderr, "Can't open DISPLAY.\n");
		exit(1);
	}
	root = RootWindow(dpy, DefaultScreen(dpy));

	// windows may get closed at wrong time. Override default error handler...
	XSetErrorHandler(errorHandler);

	if (lirc_init("irxevent", 1) == -1)
		exit(EXIT_FAILURE);

	if (lirc_readconfig(config_file, &config, check) == 0) {
		char* ir;
		char* c;
		int ret;

		if (bDaemon) {
			if (daemon(1, 0) < 0) {
				perror("Failed to run as daemon");
				exit(EXIT_FAILURE);
			}
		}

		while (lirc_nextcode(&ir) == 0) {
			if (ir == NULL)
				continue;
			while ((ret = lirc_code2char(config, ir, &c)) == 0 && c != NULL) {
				log_debug("Received code: %s Sending:\n", ir);
				bInError = 0;   // reset error state, want to see error msg

				*windowname = 0;
				if (2 == sscanf(c, "Key %s Focus WindowID %i", keyname, &WindowID) ||
				    4 == sscanf(c, "Button %d %d %d Focus WindowID %i", &pointer_button, &pointer_x,
						&pointer_y, &WindowID)
				    || 4 == sscanf(c, "xy_Key %d %d %s Focus WindowID %i", &pointer_x, &pointer_y,
						   keyname, &WindowID)
				    || 2 == sscanf(c, "Key %s Focus %s", keyname, windowname)
				    || 4 == sscanf(c, "Button %d %d %d Focus %s", &pointer_button, &pointer_x,
						   &pointer_y, windowname)
				    || 4 == sscanf(c, "xy_Key %d %d %s Focus %s", &pointer_x, &pointer_y, keyname,
						   windowname)) {
					log_debug("Focus\n");
					/* focussed ? */
					if (*windowname) {
						WindowID = find_window_focused(root, windowname);
						if (!WindowID) {
							log_debug("target window '%s' doesn't have focus\n",
								  windowname);
							continue;
						}
						log_debug("focused:  %s\n", windowname);
					} else {
						Window cur;
						int tmp;

						XGetInputFocus(dpy, &cur, &tmp);
						if (WindowID != cur) {
							log_debug("target window '0x%x' doesn't have focus\n",
								  WindowID);
							continue;
						}
						log_debug("focused:  0x%x\n", WindowID);
					}
				} else if (2 == sscanf(c, "Key %s WindowID %i", keyname, &WindowID) ||
					   4 == sscanf(c, "Button %d %d %d WindowID %i", &pointer_button, &pointer_x,
						       &pointer_y, &WindowID)
					   || 4 == sscanf(c, "xy_Key %d %d %s WindowID %i", &pointer_x, &pointer_y,
							  keyname, &WindowID)) {
					log_debug("WindowID:  0x%x\n", WindowID);
					/* WindowID passed */
				} else if (2 == sscanf(c, "Key %s %s", keyname, windowname) ||
					   4 == sscanf(c, "Button %d %d %d %s", &pointer_button, &pointer_x, &pointer_y,
						       windowname)
					   || 4 == sscanf(c, "xy_Key %d %d %s %s\n", &pointer_x, &pointer_y, keyname,
							  windowname)) {
					log_debug("name: %s\n", windowname);
					WindowID = find_window(root, windowname);
					if (WindowID == 0) {
						log_debug("target window '%s' not found\n", windowname);
						continue;
					}
				}

				switch (c[0]) {
				case 'K':       // Key
					log_debug("keyname: %s \t WindowID: 0x%x\n", keyname, WindowID);
					log_debug("%s\n", c);
					sendkey(keyname, 1, 1, (Window)WindowID, 0);
					break;

				case 'B':       // Button
				case 'x':       // xy_Key
					subw = find_sub_window(root, windowname, &pointer_x, &pointer_y);
					if (subw) {
						if (WindowID == subw)
							subw = 0;
						log_debug("%s\n", c);
						switch (c[0]) {
						case 'B':
							/* FIXME: pointer_button potentially uninititalzed. */
							sendbutton(pointer_button, pointer_x, pointer_y, WindowID,
								   subw);
							break;
						case 'x':
							sendkey(keyname, pointer_x, pointer_y, WindowID, subw);
							break;
						}
					}
					break;
				}
			}
			free(ir);
			if (ret == -1)
				break;
		}
		lirc_freeconfig(config);
	}

	lirc_deinit();

	exit(0);
}
Esempio n. 26
0
int main(int argc, char* argv[])
{
	int fd_io;
	int fd_cmd;
	const char* socketpath;
	char path[128];
	int c;

	while ((c = getopt_long(argc, argv, "hl:p:t:v", opts, NULL)) != EOF) {
		switch (c) {
		case 'l':
			opt_lircrc = optarg;
			break;
		case 'p':
			opt_prog = optarg;
			break;
		case 't':
			opt_testdata = optarg;
			break;
		case 'h':
			puts(USAGE);
			return EXIT_SUCCESS;
		case 'v':
			printf("%s\n", "irtestcase " VERSION);
			return EXIT_SUCCESS;
		case '?':
			fprintf(stderr, "unrecognized option: -%c\n", optopt);
			fputs("Try `irtestcase --help'.\n", stderr);
			return EXIT_FAILURE;
		}
	}
	if (argc > optind + 1) {
		fputs("irtestcase: Too many arguments (max one).\n", stderr);
		fputs("Try `irtestcase --help'.\n", stderr);
		return EXIT_FAILURE;
	}
	if (strcmp(opt_prog, DEFAULT_PROG) != 0 && opt_lircrc == NULL) {
		fputs("--prog requires --lircrc/-l. Giving up.\n", stderr);
		return EXIT_FAILURE;
	}
	if (opt_lircrc != NULL && strcmp(opt_prog, DEFAULT_PROG) == 0) {
		fputs("--lircrc requires --prog/-p. Giving up.\n", stderr);
		return EXIT_FAILURE;
	}

	init_testdir();
	fd_cmd = lirc_get_local_socket(NULL, 1);
	if (fd_cmd < 0) {
		fputs("Cannot open lircd socket.\n", stderr);
		exit(3);
	}
	set_devicelog(fd_cmd, DEVICE_LOG);
	if (opt_testdata != NULL)
		send_later(fd_cmd, opt_testdata);

	lirc_log_get_clientlog("irtestcase", path, sizeof(path));
	lirc_log_set_file(path);
	lirc_log_open("irtestcase", 1, LIRC_NOTICE);

	socketpath = argc == optind + 1 ? argv[optind] : LIRCD;
	setenv("LIRC_SOCKET_PATH", socketpath, 0);
	fd_io = lirc_init(opt_prog, 1);
	if (fd_io < 0) {
		fputs("Cannot run lirc_init.\n", stderr);
		exit(3);
	}

	return irtestcase(fd_io, fd_cmd);
}
//Main function
int main(int argc, char* argv[])
{
    //LIRC Variables
    struct lirc_config *config;

    //HTTP Variables
    char *host = "10.0.0.2";
    char *http_request_format = "POST /php/remote_control_api.php HTTP/1.1\n"
                                "Host: 10.0.0.2\n"
                                "Content-Type: application/x-www-form-urlencoded\n"
                                "Content-Length: 10\n\n"
                                "function=%s\n";
    char http_request[MAX_HTTP_REQUEST_LEN];
    char http_response[MAX_HTTP_RESPONSE_LEN];

    //Socket Variables
    int sockfd, error;
    struct addrinfo hints, *addrinfo_list, *addrinfo;

    //Misc Variables
    int valid_key = 0;
    struct timeval tv;
    gettimeofday(&tv, NULL);
    time_t start_time = tv.tv_sec, end_time, time_delay;

    //Outputs usage and exits if given more than one file path in arguments
    if (argc>2)
    {
        fprintf(stderr, "Usage: %s <config file>\n", argv[0]);
        return -1;
    }

    //Initializes LIRC and exits if unsuccessful, called at start of execution
    if (lirc_init("lirc",1)==-1)
    {
        fprintf(stderr, "lirc_init: failed to initialize lirc\n");
        return -1;
    }

    //Clears hints structure and set appropriately for call to getaddrinfo()
    memset(&hints, 0, sizeof hints);
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;

    //Gets the linked list of possible addrinfo structures
    if (error = getaddrinfo(host, PORT, &hints, &addrinfo_list) != 0)
    {
        fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(error));
        return -1;
    }

    //Iterate through linked list of possible addrinfo structures and attempts to create socket to connect to
    for (addrinfo = addrinfo_list; addrinfo != NULL; addrinfo = addrinfo->ai_next)
    {
        //Creates a socket
        if ((sockfd = socket(addrinfo->ai_family, addrinfo->ai_socktype, addrinfo->ai_protocol)) == -1)
        {
            continue;
        }

        //Connect to socket
        if (connect(sockfd, addrinfo->ai_addr, addrinfo->ai_addrlen) == -1)
        {
            close(sockfd);
            continue;
        }

        //Break out of loop if calls to socket() and connect() are both successful
        break;
    }

    //If none of the addrinfo structures in the linked list works, then exit program
    if (addrinfo == NULL)
    {
        fprintf(stderr, "failed to connect to %s\n", host);
        return -1;
    }

    fprintf(stdout, "connection to %s was successful\n\n", host);

    close(sockfd);

    //Read in configuration file from either argument or default path
    if (lirc_readconfig(argc==2 ? argv[1]:NULL, &config, NULL) == 0)
    {
        char *code; //Used to store the key code of the remote

        //Blocks the program until an IR signal is recieved from key press
        while (lirc_nextcode(&code)==0)
        {
            //Handle logic key press, if any
            if (code==NULL) continue;
            {
                gettimeofday(&tv, NULL);
                end_time = tv.tv_sec;
                printf("Starttime=%ld\tEndtime=%ld\n\n", start_time, end_time);
                if (end_time - start_time > DELAY)
                {
                    //Clears request and response buffer
                    memset(&http_request, 0, sizeof http_request);
                    memset(&http_response, 0, sizeof http_response);

                    if (strstr(code,"KEY_POWER"))
                    {
                        if ((valid_key = handle_key_power(http_request, http_request_format)) == -1) { return -1; }
                    }
                    else if (strstr(code,"KEY_STOP"))
                    {
                        if ((valid_key = handle_key_stop(http_request, http_request_format)) == -1) { return -1; }
                    }
                    else if (strstr(code,"KEY_PAUSE"))
                    {
                        if ((valid_key = handle_key_pause(http_request, http_request_format)) == -1) { return -1; }
                    }
                    else if (strstr(code,"KEY_PLAY"))
                    {
                        if ((valid_key = handle_key_play(http_request, http_request_format)) == -1) { return -1; }
                    }
                    else if (strstr(code,"KEY_REWIND"))
                    {
                        if ((valid_key = handle_key_rewind(http_request, http_request_format)) == -1) { return -1; }
                    }
                    else if (strstr(code,"KEY_FORWARD"))
                    {
                        if ((valid_key = handle_key_forward(http_request, http_request_format)) == -1) { return -1; }
                    }

                    if (valid_key)
                    {
                        //Creates socket
                        if ((sockfd = socket(addrinfo->ai_family, addrinfo->ai_socktype, addrinfo->ai_protocol)) == -1)
                        {
                            return -1;
                        }

                        //Connect to socket
                        if (connect(sockfd, addrinfo->ai_addr, addrinfo->ai_addrlen) == -1)
                        {
                            close(sockfd);
                            return -1;
                        }

                        if (send_http_request(sockfd, http_request) == -1)
                        {
                            fprintf(stderr, "An error has occur while sending the HTTP request\n");
                        }
                        else
                        {
                            fprintf(stdout, "HTTP request has been sent successfully.\n"
                                            "--------------------------------------------------\n"
                                            "%s\n\n", http_request);
                        }

                        if (receive_http_response(sockfd, http_response) == -1)
                        {
                            fprintf(stderr, "An error has occur while receiving the HTTP response\n");
                        }
                        else
                        {
                            fprintf(stdout, "HTTP response has been received successfully.\n"
                                            "--------------------------------------------------\n"
                                            "%s\n\n", http_response);
                        }

                        close(sockfd);
                    }
                    gettimeofday(&tv, NULL);
                    start_time = tv.tv_sec;
                }
            }
            free(code); //Free allocated memory for code after key press is handled
        }
        lirc_freeconfig(config); //Free allocated memory for configuration structure
    }

    //Deallocate memory from linked list of addrinfo structures
    freeaddrinfo(addrinfo_list);

    lirc_deinit(); //Deinitializes LIRC, called at end of program execution

    return 0; //EXIT_SUCCESS
} //end of main()
Esempio n. 28
0
int main(int argc, char *argv[])
{
   int p=0, w=0, h=0, x=-1000000, y=-1000000;
   //GdkGeometry geom;

   channels = NULL;
   current_channel = -1;
   previous_channel = -1;
   lirc_dev = NULL;
   channelcombo = NULL;

   gtk_init(&argc, &argv);
   if (!parse_command_line_options(&argc, &argv, &p, &w, &h, &x, &y)) return 1;
   load_options(w?NULL:&w, h?NULL:&h, x!=-1000000?NULL:&x, y!=-1000000?NULL:&y);
   if (p) port = p;

   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   gtk_signal_connect (GTK_OBJECT (window), "delete_event",
      GTK_SIGNAL_FUNC (delete_event), NULL);
   gtk_signal_connect (GTK_OBJECT (window), "destroy",
      GTK_SIGNAL_FUNC (destroy), NULL);
   gtk_window_set_policy(GTK_WINDOW(window), 1, 1, 0);

   gtk_window_set_title (GTK_WINDOW (window), "Linux Video Studio TV");
   gtk_container_set_border_width (GTK_CONTAINER (window), 0);

   tv = gtk_tvplug_new(port);
   if (!tv)
   {
      g_print("ERROR: no suitable video4linux device found\n");
      g_print("Please supply a video4linux Xv-port manually (\'stv -p <num>\')\n");
      return 1;
   }
   if (channels)
   {
      int i;
      for(i=0;channels[i];i++)
         if (channels[i]->frequency == (int)GTK_TVPLUG(tv)->frequency_adj->value)
         {
            current_channel = i;
            break;
         }
   }
   if (!port) port = GTK_TVPLUG(tv)->port;
   GTK_WIDGET_SET_FLAGS(tv, GTK_CAN_FOCUS); /* key press events */
   gtk_container_add (GTK_CONTAINER (window), tv);
   gtk_widget_show(tv);
   set_background_color(tv, 0, 0, 0);

   gtk_signal_connect(GTK_OBJECT(tv), "button_press_event",
      GTK_SIGNAL_FUNC(tv_clicked), NULL);
   gtk_signal_connect(GTK_OBJECT(window), "key_press_event",
      GTK_SIGNAL_FUNC(tv_typed), NULL);
   gtk_signal_connect(GTK_OBJECT(window), "focus_in_event",
      GTK_SIGNAL_FUNC(focus_in_event), NULL);
   gtk_signal_connect(GTK_OBJECT(window), "focus_out_event",
      GTK_SIGNAL_FUNC(focus_out_event), NULL);
   set_background_color(window, 0, 0, 0);

   input_init();
#if 0
   geom.min_width = GTK_TVPLUG(tv)->width_best/16;
   geom.min_height = GTK_TVPLUG(tv)->height_best/16;
   geom.max_width = GTK_TVPLUG(tv)->width_best;
   geom.max_height = GTK_TVPLUG(tv)->height_best;
   geom.width_inc = GTK_TVPLUG(tv)->width_best/16;
   geom.height_inc = GTK_TVPLUG(tv)->height_best/16;
   geom.min_aspect = GTK_TVPLUG(tv)->height_best / GTK_TVPLUG(tv)->width_best - 0.05;
   geom.max_aspect = GTK_TVPLUG(tv)->height_best / GTK_TVPLUG(tv)->width_best + 0.05;
   gtk_window_set_geometry_hints(GTK_WINDOW(window), window, &geom,
      GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE | GDK_HINT_ASPECT | GDK_HINT_RESIZE_INC);
   if (w>0 && h>0) gtk_widget_set_usize(window, w, h);
   if (x!=-1000000 && y!=-1000000) gtk_widget_set_uposition(window, x, y);
#endif
#ifdef HAVE_LIRC
   lirc_init();
#endif
#ifdef OSS
   sound_init();
#endif

   gtk_widget_show(window);

   gtk_main();

   return 0;
}
Esempio n. 29
0
int main(int argc, char* argv[])
{
	int fdm, c, ignoreeof, interactive, noecho, verbose;
	pid_t pid;
	char* config;
	char slave_name[20];
	struct termios orig_termios;
	struct winsize size;
	int flags;

	interactive = isatty(STDIN_FILENO);
	ignoreeof = 0;
	noecho = 0;
	verbose = 0;
	config = NULL;

	while ((c = getopt_long(argc, argv, "hVs:einv", long_options, NULL))
	       != EOF) {
		switch (c) {
		case 'h':
			printf("Usage: %s [options] config_file -- program [args ...]\n", argv[0]);
			printf("\t -h --help \t\tdisplay usage summary\n");
			printf("\t -V --version \t\tdisplay version\n");
			printf("\t -e --no-echo \t\tdisable echo\n");
			printf("\t -i --ignore-eof \tignore EOF\n");
			printf("\t -n --non-interactive \tforce non-interactive mode\n");
			printf("\t -v --verbose \t\tverbose mode\n");
			return EXIT_SUCCESS;
		case 'V':
			printf("irpty %s\n", VERSION);
			return EXIT_SUCCESS;

		case 'e':
			noecho = 1;
			break;

		case 'i':
			ignoreeof = 1;
			break;

		case 'n':
			interactive = 0;
			break;

		case 'v':
			verbose = 1;
			break;

		case '?':
			die("unrecognized option: -%c\n", optopt);
		}
	}
	if (optind + 1 >= argc)
		die("usage: irpty [ -s server -einv ] cfg program [ arg ... ]\n");

	config = argv[optind++];

	if ((lsock = lirc_init("irpty", 1)) == -1)
		exit(EXIT_FAILURE);
	flags = fcntl(lsock, F_GETFL, 0);
	if (flags != -1)
		fcntl(lsock, F_SETFL, flags | FASYNC | O_NONBLOCK);

	if (lirc_readconfig(config, &lconfig, NULL) != 0)
		exit(EXIT_FAILURE);

	if (interactive) {
		if (tcgetattr(STDIN_FILENO, &orig_termios) < 0)
			die("tcgetattr error on stdin\n");
		if (ioctl(STDIN_FILENO, TIOCGWINSZ, (char*)&size) < 0)
			die("TIOCGWINSZ error\n");
		pid = pty_fork(&fdm, slave_name, &orig_termios, &size);
	} else {
		pid = pty_fork(&fdm, slave_name, NULL, NULL);
	}

	if (pid < 0) {
		die("fork error\n");
	} else if (!pid) {                              /* child */
		if (noecho)
			set_noecho(STDIN_FILENO);       /* stdin is slave pty */
		if (execvp(argv[optind], &argv[optind]) < 0)
			die("can't execute: %s\n", argv[optind]);
	}
	if (verbose) {
		fprintf(stderr, "slave name = %s\n", slave_name);
		if (config)
			fprintf(stderr, "config file = %s\n", config);
	}
	if (interactive) {
		if (tty_raw(STDIN_FILENO) < 0)  /* user's tty to raw mode */
			die("tty_raw error");
		if (atexit(tty_atexit) < 0)     /* reset user's tty on exit */
			die("atexit error");
	}
	copy_loop(fdm, ignoreeof);

	exit(0);
}
Esempio n. 30
0
int main(int argc, char *argv[])
{
	struct lirc_config *config;
	int daemonize=0;

	progname="irexec-" VERSION;
	while(1)
	{
		int c;
		static struct option long_options[] =
		{
			{"help",no_argument,NULL,'h'},
			{"version",no_argument,NULL,'v'},
#ifdef DAEMONIZE
			{"daemon",no_argument,NULL,'d'},
#endif
			{0, 0, 0, 0}
		};
		c = getopt_long(argc,argv,"hvd",long_options,NULL);
		if(c==-1)
			break;
		switch (c)
		{
		case 'h':
			printf("Usage: %s [options] [config_file]\n",argv[0]);
			printf("\t -h --help\t\tdisplay this message\n");
			printf("\t -v --version\t\tdisplay version\n");
#ifdef DAEMONIZE
			printf("\t -d --daemon\t\trun in background\n");
#endif
			return(EXIT_SUCCESS);
		case 'v':
			printf("%s\n",progname);
			return(EXIT_SUCCESS);
#ifdef DAEMONIZE
		case 'd':
			daemonize=1;
			break;
#endif
		default:
			printf("Usage: %s [options] [config_file]\n",argv[0]);
			return(EXIT_FAILURE);
		}
	}
	if (optind < argc-1)
	{
		fprintf(stderr,"%s: too many arguments\n",progname);
		return(EXIT_FAILURE);
	}
	
	if(lirc_init("irexec",daemonize ? 0:1)==-1) exit(EXIT_FAILURE);

	if(lirc_readconfig(optind!=argc ? argv[optind]:NULL,&config,NULL)==0)
	{
		char *code;
		char *c;
		int ret;

#ifdef DAEMONIZE
		if(daemonize)
		{
			if(daemon(0,0)==-1)
			{
				fprintf(stderr,"%s: can't daemonize\n",
					progname);
				perror(progname);
				lirc_freeconfig(config);
				lirc_deinit();
				exit(EXIT_FAILURE);
			}
		}
#endif
		while(lirc_nextcode(&code)==0)
		{
			if(code==NULL) continue;
			while((ret=lirc_code2char(config,code,&c))==0 &&
			      c!=NULL)
			{
#if defined(DAEMONIZE) && defined(DEBUG)
				if(!daemonize)
				{
					printf("Execing command \"%s\"\n",c);
				}
#endif
				system(c);
			}
			free(code);
			if(ret==-1) break;
		}
		lirc_freeconfig(config);
	}

	lirc_deinit();
	exit(EXIT_SUCCESS);
}