int main(int argc, char **argv)
{
unsigned long long the_num;
struct afactor_struct **fc_ptr;
struct afactor_struct *factor_chain;
if ((argc != 2)||(_parse_args(argc, argv, "-h", 0)))
{
printf("Usage: %s <number>\n", argv[0]);
printf("Find the largest prime factor of the specified number.\n");
return(0);
}
the_num = strtoull(_parse_args(argc, argv, 0, 0), 0, 10);
factor_chain = factors_find(the_num, 1);
fc_ptr = &factor_chain;
while (fc_ptr)
{
fprintf(stderr, "%llu\n", (*fc_ptr)->factor);
if ((*fc_ptr)->nxt)
fc_ptr = &((*fc_ptr)->nxt);
else
break;
}
return(0);
}
config::config()
: _container ( "/tmp/zapp/container" ),
_user ( "/.zapp/user" ),
_innoextract_bin ( "innoextract" ),
_dosbox_bin ( "dosbox" )
{
_user = QStandardPaths::standardLocations ( QStandardPaths::HomeLocation ) [0] + _user;
_parse_args();
_calculate_paths();
}
GError*
compound_type_parse(struct compound_type_s *ct, const gchar *srvtype)
{
EXTRA_ASSERT(ct != NULL);
memset(ct, 0, sizeof(struct compound_type_s));
if (!srvtype || !*srvtype || *srvtype == '.' || *srvtype == ';')
return NEWERROR(CODE_BAD_REQUEST, "Bad service type [%s]", srvtype);
ct->fulltype = srvtype;
gchar **tokens = g_strsplit(srvtype, ";", 2);
_parse_type(ct, tokens[0]);
_parse_args(ct, tokens[1]);
g_free(tokens);
GRID_TRACE("CT full[%s] type[%s] bare[%s] sub[%s] args[%s|%s]",
ct->fulltype, ct->type, ct->baretype, ct->subtype,
ct->req.k, ct->req.v);
return NULL;
}
int main (int argc, char **argv)
{
// print warm welcome
std::cerr << argv[0] << " v0.1\n";
// initialize libvisual once (this is meant to be called only once,
// visual_init() after visual_quit() results in undefined state)
visual_log_set_verbosity(VISUAL_LOG_DEBUG);
visual_init (&argc, &argv);
try {
// parse commandline arguments
if (_parse_args(argc, argv) != EXIT_SUCCESS)
throw std::runtime_error ("Failed to parse arguments");
// create new VisBin for video output
VisBin *bin = visual_bin_new();
visual_bin_set_supported_depth(bin, VISUAL_VIDEO_DEPTH_ALL);
visual_bin_switch_set_style(bin, VISUAL_SWITCH_STYLE_MORPH);
// initialize actor plugin
std::cerr << "Loading actor '" << actor_name << "'...\n";
VisActor *actor = visual_actor_new (actor_name.c_str ());
if (!actor)
throw std::runtime_error ("Failed to load actor '" + actor_name + "'");
// Set random seed
if (have_seed) {
VisPluginData *plugin_data = visual_actor_get_plugin(actor);
VisRandomContext *r_context = visual_plugin_get_random_context (plugin_data);
visual_random_context_set_seed (r_context, seed);
seed++;
}
// initialize input plugin
std::cerr << "Loading input '" << input_name << "'...\n";
VisInput *input = visual_input_new(input_name.c_str());
if (!input) {
throw std::runtime_error ("Failed to load input '" + input_name + "'");
}
// Pick the best display depth
int depthflag = visual_actor_get_supported_depth (actor);
VisVideoDepth depth;
if (depthflag == VISUAL_VIDEO_DEPTH_GL) {
depth = visual_video_depth_get_highest (depthflag);
}
else {
depth = visual_video_depth_get_highest_nogl (depthflag);
}
visual_bin_set_depth (bin, depth);
VisVideoAttributeOptions const* vidoptions =
visual_actor_get_video_attribute_options(actor);
// initialize display
SADisplay display (driver_name);
// create display
display.create(depth, vidoptions, width, height, true);
VisVideo *video = display.get_video();
if(!video)
throw std::runtime_error("Failed to get VisVideo from display");
// put it all together
visual_bin_connect(bin, actor, input);
visual_bin_set_video(bin, video);
visual_bin_realize(bin);
visual_bin_sync(bin, FALSE);
visual_bin_depth_changed(bin);
// get a queue to handle events
VisEventQueue localqueue;
// main loop
bool running = true;
bool visible = true;
while (running)
{
LV::Event ev;
// Handle all events
display.drain_events(localqueue);
LV::EventQueue* pluginqueue = visual_plugin_get_eventqueue(visual_actor_get_plugin (bin->actor));
while (localqueue.poll(ev))
{
if(ev.type != VISUAL_EVENT_RESIZE)
pluginqueue->add (ev);
switch (ev.type)
{
case VISUAL_EVENT_PARAM:
{
break;
}
case VISUAL_EVENT_RESIZE:
{
display.lock();
width = ev.event.resize.width;
height = ev.event.resize.height;
display.create(depth, vidoptions, width, height, true);
video = display.get_video ();
visual_bin_set_video (bin, video);
visual_actor_video_negotiate (bin->actor, depth, FALSE, FALSE);
display.unlock();
break;
}
case VISUAL_EVENT_MOUSEMOTION:
{
break;
}
case VISUAL_EVENT_MOUSEBUTTONDOWN:
{
// switch to next actor
v_cycleActor(1);
v_cycleMorph();
visual_bin_set_morph_by_name(bin, morph_name.c_str());
visual_bin_switch_actor_by_name(bin, actor_name.c_str());
// get new actor
actor = visual_bin_get_actor(bin);
// handle depth of new actor
depthflag = visual_actor_get_supported_depth(actor);
if (depthflag == VISUAL_VIDEO_DEPTH_GL)
{
visual_bin_set_depth(bin, VISUAL_VIDEO_DEPTH_GL);
}
else
{
depth = visual_video_depth_get_highest(depthflag);
if ((bin->depthflag & depth) > 0)
visual_bin_set_depth(bin, depth);
else
visual_bin_set_depth(bin, visual_video_depth_get_highest_nogl(bin->depthflag));
}
bin->depthforcedmain = bin->depth;
break;
}
case VISUAL_EVENT_MOUSEBUTTONUP:
{
break;
}
case VISUAL_EVENT_KEYDOWN:
{
switch(ev.event.keyboard.keysym.sym)
{
case VKEY_ESCAPE:
{
running = false;
break;
}
case VKEY_TAB:
{
break;
}
default:
break;
}
break;
}
case VISUAL_EVENT_KEYUP:
{
break;
}
case VISUAL_EVENT_QUIT:
{
running = FALSE;
break;
}
case VISUAL_EVENT_VISIBILITY:
{
visible = ev.event.visibility.is_visible;
break;
}
default:
{
break;
}
}
}
if (visual_bin_depth_changed(bin))
{
display.lock();
display.create(depth, vidoptions, width, height, true);
VisVideo *video = display.get_video();
visual_bin_set_video(bin, video);
visual_bin_sync(bin, TRUE);
display.unlock();
}
// Do a run cycle
if (!visible)
continue;
display.lock();
visual_bin_run(bin);
display.unlock();
display.update_all();
display.set_fps_limit(framerate);
}
}
catch (std::exception& error) {
std::cerr << error.what () << std::endl;
}
//printf ("Total frames: %d, average fps: %f\n", display_fps_total (display), display_fps_average (display));
visual_quit ();
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
/* current configuration */
LedPrefs *p = NULL;
/** current setup */
LedSetup *s = NULL;
/** list of LED hardware adapters */
LedHardware *hw = NULL;
/* input pixel-frame buffer */
LedFrame *frame = NULL;
/** width of map */
LedFrameCord width;
/** height of map */
LedFrameCord height;
/* check libniftyled binary version compatibility */
NFT_LED_CHECK_VERSION
/* set default loglevel to INFO */
nft_log_level_set(L_INFO);
/* initialize exit handlers */
#if WIN32
int signals[] = { SIGINT, SIGABRT };
#else
int signals[] = { SIGHUP, SIGINT, SIGQUIT, SIGABRT };
#endif
unsigned int i;
for(i=0; i<sizeof(signals)/sizeof(int); i++)
{
if(signal(signals[i], _exit_signal_handler) == SIG_ERR)
{
NFT_LOG_PERROR("signal()");
return -1;
}
}
/* default result of main() function */
int res = -1;
/* default fps */
_c.fps = 25;
/* default endianess */
_c.is_big_endian = FALSE;
#if HAVE_IMAGEMAGICK == 1
/* default handle-input-as-raw */
_c.raw = FALSE;
#endif
/* default looping */
_c.do_loop = FALSE;
/* set "running" flag */
_c.running = TRUE;
/* default pixel-format */
strncpy(_c.pixelformat, "RGB u8", sizeof(_c.pixelformat));
/* default prefs-filename */
if(!led_prefs_default_filename(_c.prefsfile, sizeof(_c.prefsfile), ".ledcat.xml"))
return -1;
/* parse commandline arguments */
if(!_parse_args(argc, argv))
return -1;
/* print welcome msg */
NFT_LOG(L_INFO, "%s %s (c) D.Hiepler 2006-2012", PACKAGE_NAME, ledcat_version_long());
NFT_LOG(L_VERBOSE, "Loglevel: %s", nft_log_level_to_string(nft_log_level_get()));
#if HAVE_IMAGEMAGICK == 1
/* initialize imagemagick */
if(!_c.raw)
{
if(!im_init(&_c))
{
NFT_LOG(L_ERROR, "Failed to initialize ImageMagick");
return -1;
}
}
#endif
/* initialize preferences context */
if(!(p = led_prefs_init()))
return -1;
/* parse prefs-file */
LedPrefsNode *pnode;
if(!(pnode = led_prefs_node_from_file(_c.prefsfile)))
{
NFT_LOG(L_ERROR, "Failed to open configfile \"%s\"",
_c.prefsfile);
goto m_deinit;
}
/* create setup from prefs-node */
if(!(s = led_prefs_setup_from_node(p, pnode)))
{
NFT_LOG(L_ERROR, "No valid setup found in preferences file.");
led_prefs_node_free(pnode);
goto m_deinit;
}
/* free preferences node */
led_prefs_node_free(pnode);
/* determine width of input-frames */
if(!_c.width)
/* width of mapped chain */
width = led_setup_get_width(s);
else
/* use value from cmdline arguments */
width = _c.width;
/* determine height of input-frames */
if(!_c.height)
/* height of mapped chain */
height = led_setup_get_height(s);
else
height = _c.height;
/* validate dimensions */
if(width <= 0 || height <= 0)
{
NFT_LOG(L_ERROR, "Dimensions %dx%d not possible in this universe. Exiting.", width, height);
goto m_deinit;
}
/* allocate frame (where our pixelbuffer resides) */
NFT_LOG(L_INFO, "Allocating frame: %dx%d (%s)",
width, height, _c.pixelformat);
LedPixelFormat *format = led_pixel_format_from_string(_c.pixelformat);
if(!(frame = led_frame_new(width, height, format)))
goto m_deinit;
/* get first toplevel hardware */
if(!(hw = led_setup_get_hardware(s)))
goto m_deinit;
/* initialize hardware */
/*if(!(led_hardware_init(hw, ledcount, (LedGreyscaleFormat) format)))
{
NFT_LOG(L_ERROR, "failed to initialize hardware.");
goto m_deinit;
}*/
/* initialize pixel->led mapping */
if(!led_hardware_list_refresh_mapping(hw))
goto m_deinit;
/* precalc memory offsets for actual mapping */
LedHardware *ch;
for(ch = hw; ch; ch = led_hardware_list_get_next(ch))
{
if(!led_chain_map_from_frame(led_hardware_get_chain(ch), frame))
goto m_deinit;
}
/* set correct gain to hardware */
if(!led_hardware_list_refresh_gain(hw))
goto m_deinit;
#if HAVE_IMAGEMAGICK == 1
/* determine format that ImageMagick should provide */
if(!_c.raw)
{
if(!(im_format(&_c, format)))
{
NFT_LOG(L_ERROR, "Failed to determine valid ImageMagick format");
goto m_deinit;
}
}
#endif
/* do we have at least one filename? */
if(!_c.files[0])
{
NFT_LOG(L_ERROR, "No input file(s) given");
goto m_deinit;
}
/* initially sample time for frame-timing */
if(!led_fps_sample())
goto m_deinit;
#if ! WIN32
/* initialize alarm-signal handler for periodical fps output */
{
struct sigaction sa;
struct itimerval timer;
memset(&sa, 0, sizeof(sa));
sa.sa_handler = &_alarm_signal_handler;
sigaction(SIGALRM, &sa, NULL);
timer.it_value.tv_sec = 1;
timer.it_value.tv_usec = 0;
timer.it_interval.tv_sec = 1;
timer.it_interval.tv_usec = 0;
setitimer(ITIMER_REAL, &timer, NULL);
}
#endif
/* get data-buffer of frame to write our pixels to */
char *buf;
if(!(buf = led_frame_get_buffer(frame)))
{
NFT_LOG(L_ERROR, "Frame has NULL buffer");
goto m_deinit;
}
/* walk all files (supplied as commandline arguments) and output them */
int filecount;
for(filecount = 0; _c.files[filecount]; filecount++)
{
NFT_LOG(L_VERBOSE, "Getting pixels from \"%s\"", _c.files[filecount]);
/* open file */
if(_c.files[filecount][0] == '-' && strlen(_c.files[filecount]) == 1)
{
_c.fd = STDIN_FILENO;
}
else
{
if((_c.fd = open(_c.files[filecount], O_RDONLY)) < 0)
{
NFT_LOG(L_ERROR, "Failed to open \"%s\": %s",
_c.files[filecount], strerror(errno));
continue;
}
}
#if HAVE_IMAGEMAGICK == 1
/** initialize stream for ImageMagick */
if(!_c.raw)
{
if(!(im_open_stream(&_c)))
continue;
}
#endif
/* output file frame-by-frame */
while(_c.running)
{
#if HAVE_IMAGEMAGICK == 1
/* use imagemagick to load file if we're not in "raw-mode" */
if(!_c.raw)
{
/* load frame to buffer using ImageMagick */
if(!im_read_frame(&_c, width, height, buf))
break;
}
else
{
#endif
/* read raw frame */
if(raw_read_frame(&_c.running, buf, _c.fd,
led_pixel_format_get_buffer_size(
led_frame_get_format(frame),
led_frame_get_width(frame)*led_frame_get_height(frame))) == 0)
continue;
#if HAVE_IMAGEMAGICK == 1
}
#endif
/* set endianess (flag will be changed when conversion occurs) */
led_frame_set_big_endian(frame, _c.is_big_endian);
/* print frame for debugging */
//nft_frame_buffer_print(frame);
/* fill chain of every hardware from frame */
LedHardware *h;
for(h = hw; h; h = led_hardware_list_get_next(h))
{
if(!led_chain_fill_from_frame(led_hardware_get_chain(h), frame))
{
NFT_LOG(L_ERROR, "Error while mapping frame");
break;
}
}
/* send frame to hardware(s) */
NFT_LOG(L_DEBUG, "Sending frame");
led_hardware_list_send(hw);
/* delay in respect to fps */
if(!led_fps_delay(_c.fps))
break;
/* latch hardware */
NFT_LOG(L_DEBUG, "Showing frame");
led_hardware_list_show(hw);
/* save time when frame is displayed */
if(!led_fps_sample())
break;
/* clear frame */
//nft_frame_clear_buffer(frame);
}
#if HAVE_IMAGEMAGICK == 1
if(!_c.raw)
im_close_stream(&_c);
#else
close(_c.fd);
#endif
/* loop endlessly? */
if((_c.running) && (!_c.files[filecount+1]) && _c.do_loop)
{
/* start over by resetting the for-loop */
filecount = -1;
}
}
/* all ok */
res = 0;
m_deinit:
/* free setup */
led_setup_destroy(s);
/* free frame */
led_frame_destroy(frame);
/* destroy config */
led_prefs_deinit(p);
#if HAVE_IMAGEMAGICK == 1
/* deinitialize ImageMagick */
im_deinit(&_c);
#endif
return res;
}
static int
_parseline(conffile_t cf, char *linebuf, int linebuflen)
{
int i, optionlen, rv, numargs = 0;
char args[CONFFILE_MAX_ARGS][CONFFILE_MAX_ARGLEN];
struct conffile_option *option = NULL;
struct conffile_data data;
char *ptr;
memset(&data, '\0', sizeof(struct conffile_data));
linebuflen = _remove_trailing_whitespace(cf, linebuf, linebuflen);
if (linebuflen == 0)
return 0;
if ((linebuf = _move_past_whitespace(cf, linebuf)) == NULL)
return 0;
optionlen = 0;
memset(cf->optionname, '\0', CONFFILE_MAX_OPTIONNAMELEN);
while (optionlen < (CONFFILE_MAX_OPTIONNAMELEN-1)
&& !isspace(*linebuf)
&& *linebuf != '\0') {
cf->optionname[optionlen++] = *linebuf;
linebuf++;
}
/* minus one to guarantee null termination */
if (optionlen == (CONFFILE_MAX_OPTIONNAMELEN-1)) {
cf->errnum = CONFFILE_ERR_PARSE_OVERFLOW_OPTIONLEN;
return -1;
}
for (i = 0; i < cf->options_len; i++) {
int rv;
if (cf->flags & CONFFILE_FLAG_OPTION_CASESENSITIVE)
rv = strcmp(cf->options[i].optionname, cf->optionname);
else
rv = strcasecmp(cf->options[i].optionname, cf->optionname);
if (rv == 0) {
option = &(cf->options[i]);
break;
}
}
if (option == NULL) {
if (cf->flags & CONFFILE_FLAG_OPTION_IGNORE_UNKNOWN)
return 0;
cf->errnum = CONFFILE_ERR_PARSE_OPTION_UNKNOWN;
return -1;
}
if (option->option_type == CONFFILE_OPTION_IGNORE)
return 0;
(*option->count_ptr)++;
if (option->max_count > 0) {
if ((*option->count_ptr) > option->max_count) {
cf->errnum = CONFFILE_ERR_PARSE_OPTION_TOOMANY;
return -1;
}
}
if ((linebuf = _move_past_whitespace(cf, linebuf)) != NULL) {
if ((numargs = _parse_args(cf, linebuf, args)) < 0)
return -1;
}
/* Argument checks */
if (option->option_type == CONFFILE_OPTION_FLAG && numargs != 0) {
cf->errnum = CONFFILE_ERR_PARSE_ARG_TOOMANY;
return -1;
}
if (((option->option_type == CONFFILE_OPTION_BOOL
|| option->option_type == CONFFILE_OPTION_INT
|| option->option_type == CONFFILE_OPTION_DOUBLE
|| option->option_type == CONFFILE_OPTION_STRING
|| option->option_type == CONFFILE_OPTION_LIST_INT
|| option->option_type == CONFFILE_OPTION_LIST_DOUBLE
|| option->option_type == CONFFILE_OPTION_LIST_STRING)
&& numargs == 0)) {
cf->errnum = CONFFILE_ERR_PARSE_ARG_MISSING;
return -1;
}
if (((option->option_type == CONFFILE_OPTION_BOOL
|| option->option_type == CONFFILE_OPTION_INT
|| option->option_type == CONFFILE_OPTION_DOUBLE
|| option->option_type == CONFFILE_OPTION_STRING)
&& numargs > 1)) {
cf->errnum = CONFFILE_ERR_PARSE_ARG_TOOMANY;
return -1;
}
if ((option->option_type == CONFFILE_OPTION_LIST_INT
|| option->option_type == CONFFILE_OPTION_LIST_DOUBLE
|| option->option_type == CONFFILE_OPTION_LIST_STRING)
&& ((int)option->option_type_arg) > 0
&& numargs != ((int)option->option_type_arg)) {
if (numargs < ((int)option->option_type_arg))
cf->errnum = CONFFILE_ERR_PARSE_ARG_MISSING;
else
cf->errnum = CONFFILE_ERR_PARSE_ARG_TOOMANY;
return -1;
}
if (option->option_type == CONFFILE_OPTION_BOOL) {
if (strcmp(args[0], "1") != 0
&& strcmp(args[0], "0") != 0
&& strcasecmp(args[0], "y") != 0
&& strcasecmp(args[0], "n") != 0
&& strcasecmp(args[0], "yes") != 0
&& strcasecmp(args[0], "no") != 0
&& strcasecmp(args[0], "on") != 0
&& strcasecmp(args[0], "off") != 0
&& strcasecmp(args[0], "t") != 0
&& strcasecmp(args[0], "f") != 0
&& strcasecmp(args[0], "true") != 0
&& strcasecmp(args[0], "false") != 0
&& strcasecmp(args[0], "enable") != 0
&& strcasecmp(args[0], "disable") != 0) {
cf->errnum = CONFFILE_ERR_PARSE_ARG_INVALID;
return -1;
}
}
/* Calculate Data */
if (option->option_type == CONFFILE_OPTION_BOOL) {
if (!strcmp(args[0], "1")
|| !strcasecmp(args[0], "y")
|| !strcasecmp(args[0], "yes")
|| !strcasecmp(args[0], "on")
|| !strcasecmp(args[0], "t")
|| !strcasecmp(args[0], "true")
|| !strcasecmp(args[0], "enable"))
data.boolval = 1;
else
data.boolval = 0;
}
else if (option->option_type == CONFFILE_OPTION_INT) {
errno = 0;
data.intval = strtol(args[0], &ptr, 0);
if (errno || (args[0] + strlen(args[0])) != ptr) {
cf->errnum = CONFFILE_ERR_PARSE_ARG_INVALID;
return -1;
}
}
else if (option->option_type == CONFFILE_OPTION_DOUBLE) {
errno = 0;
data.doubleval = strtod(args[0], &ptr);
if (errno || (args[0] + strlen(args[0])) != ptr) {
cf->errnum = CONFFILE_ERR_PARSE_ARG_INVALID;
return -1;
}
}
else if (option->option_type == CONFFILE_OPTION_STRING) {
strncpy(data.string, args[0], CONFFILE_MAX_ARGLEN);
data.string[CONFFILE_MAX_ARGLEN - 1] = '\0';
}
else if (option->option_type == CONFFILE_OPTION_LIST_INT) {
int i;
for (i = 0; i < numargs; i++) {
errno = 0;
data.intlist[i] = strtol(args[i], &ptr, 0);
if (errno || (args[i] + strlen(args[i])) != ptr) {
cf->errnum = CONFFILE_ERR_PARSE_ARG_INVALID;
return -1;
}
}
data.intlist_len = numargs;
}
else if (option->option_type == CONFFILE_OPTION_LIST_DOUBLE) {
int i;
for (i = 0; i < numargs; i++) {
errno = 0;
data.doublelist[i] = strtod(args[i], &ptr);
if (errno || (args[i] + strlen(args[i])) != ptr) {
cf->errnum = CONFFILE_ERR_PARSE_ARG_INVALID;
return -1;
}
}
data.doublelist_len = numargs;
}
else if (option->option_type == CONFFILE_OPTION_LIST_STRING) {
int i;
for (i = 0; i < numargs; i++) {
strncpy(data.stringlist[i], args[i], CONFFILE_MAX_ARGLEN);
data.stringlist[i][CONFFILE_MAX_ARGLEN - 1] = '\0';
}
data.stringlist_len = numargs;
}
cf->errnum = CONFFILE_ERR_SUCCESS;
if (option->callback_func) {
rv = (option->callback_func)(cf,
&data,
option->optionname,
option->option_type,
option->option_ptr,
option->option_data,
cf->app_ptr,
cf->app_data);
if (rv < 0) {
if (cf->errnum == CONFFILE_ERR_SUCCESS)
cf->errnum = CONFFILE_ERR_PARSE_CALLBACK;
return -1;
}
}
return 0;
}
int main(int argc, char *argv[])
{
/** return value of main() */
int res = 1;
/* current configuration */
LedPrefs *prefs = NULL;
/* current setup */
LedSetup *setup = NULL;
/** framebuffer for captured image */
LedFrame *frame = NULL;
/* check binary version compatibility */
NFT_LED_CHECK_VERSION
/* set default loglevel to INFO */
nft_log_level_set(L_INFO);
/* initialize exit handlers */
int signals[] = { SIGHUP, SIGINT, SIGQUIT, SIGABRT };
unsigned int i;
for(i=0; i<sizeof(signals)/sizeof(int); i++)
{
if(signal(signals[i], _exit_signal_handler) == SIG_ERR)
{
NFT_LOG_PERROR("signal()");
goto _m_exit;
}
}
/* default fps */
_c.fps = 25;
/* default mechanism */
_c.method = METHOD_MIN+1;
/* default config-filename */
if(!led_prefs_default_filename(_c.prefsfile, sizeof(_c.prefsfile), ".ledcap.xml"))
goto _m_exit;
/* parse cmdline-arguments */
if(!_parse_args(argc, argv))
goto _m_exit;
/* print welcome msg */
NFT_LOG(L_INFO, "%s %s (c) D.Hiepler 2006-2012", PACKAGE_NAME, ledcap_version_long());
NFT_LOG(L_VERBOSE, "Loglevel: %s", nft_log_level_to_string(nft_log_level_get()));
/* initialize preferences context */
if(!(prefs = led_prefs_init()))
return -1;
/* parse prefs-file */
LedPrefsNode *pnode;
if(!(pnode = led_prefs_node_from_file(_c.prefsfile)))
{
NFT_LOG(L_ERROR, "Failed to open configfile \"%s\"",
_c.prefsfile);
goto _m_exit;
}
/* create setup from prefs-node */
if(!(setup = led_prefs_setup_from_node(prefs, pnode)))
{
NFT_LOG(L_ERROR, "No valid setup found in preferences file.");
led_prefs_node_free(pnode);
goto _m_exit;
}
/* free preferences node */
led_prefs_node_free(pnode);
/* determine width of input-frames */
LedFrameCord width, height;
if((width = led_setup_get_width(setup)) > _c.width)
{
NFT_LOG(L_WARNING, "LED-Setup width (%d) > our width (%d). Using setup-value",
width,_c.width);
/* use dimensions of mapped chain */
_c.width = width;
}
/* determine height of input-frames */
if((height = led_setup_get_height(setup)) > _c.height)
{
NFT_LOG(L_WARNING, "LED-Setup height (%d) > our height (%d). Using setup-value.",
height, _c.height);
/* use dimensions of mapped chain */
_c.height = height;
}
if(_c.width < 0)
{
NFT_LOG(L_ERROR, "width (%d) < 0", _c.width);
goto _m_exit;
}
if(_c.height < 0)
{
NFT_LOG(L_ERROR, "height (%d) < 0", _c.height);
goto _m_exit;
}
/* sanitize x-offset @todo check for maximum */
if(_c.x < 0)
{
NFT_LOG(L_ERROR, "Invalid x coordinate: %d, using 0", _c.x);
_c.x = 0;
}
/* sanitize y-offset @todo check for maximum */
if(_c.y < 0)
{
NFT_LOG(L_ERROR, "Invalid y coordinate: %d, using 0", _c.y);
_c.y = 0;
}
/* initialize capture mechanism (only imlib for now) */
if(!capture_init(_c.method))
goto _m_exit;
/* allocate framebuffer */
NFT_LOG(L_INFO, "Allocating frame: %dx%d (%s)",
_c.width, _c.height, capture_format());
if(!(frame = led_frame_new(_c.width, _c.height, led_pixel_format_from_string(capture_format()))))
goto _m_exit;
/* respect endianess */
led_frame_set_big_endian(frame, capture_is_big_endian());
/* get first hardware */
LedHardware *hw;
if(!(hw = led_setup_get_hardware(setup)))
goto _m_exit;
/* initialize pixel->led mapping */
if(!led_hardware_list_refresh_mapping(hw))
goto _m_exit;
/* precalc memory offsets for actual mapping */
if(!led_chain_map_from_frame(led_hardware_get_chain(hw), frame))
goto _m_exit;
/* set saved gain to all registered hardware instances */
if(!led_hardware_list_refresh_gain(hw))
goto _m_exit;
/* print some debug-info */
led_frame_print(frame, L_VERBOSE);
led_hardware_print(hw, L_VERBOSE);
/* initially sample time for frametiming */
if(!led_fps_sample())
goto _m_exit;
/* output some useful info */
NFT_LOG(L_INFO, "Capturing %dx%d pixels at position x/y: %d/%d", _c.width, _c.height, _c.x, _c.y);
/* loop until _c.running is set to FALSE */
_c.running = TRUE;
while(_c.running)
{
/* capture frame */
if(!(capture_frame(frame, _c.x, _c.y)))
break;
/* print frame for debugging */
//led_frame_buffer_print(frame);
/* map from frame */
LedHardware *h;
for(h = hw; h; h = led_hardware_list_get_next(h))
{
if(!led_chain_fill_from_frame(led_hardware_get_chain(h), frame))
{
NFT_LOG(L_ERROR, "Error while mapping frame");
break;
}
}
/* send frame to hardware(s) */
led_hardware_list_send(hw);
/* delay in respect to fps */
if(!led_fps_delay(_c.fps))
break;
/* show frame */
led_hardware_list_show(hw);
/* save time when frame is displayed */
if(!led_fps_sample())
break;
}
/* mark success */
res = 0;
_m_exit:
/* deinitialize capture mechanism */
capture_deinit();
/* free frame */
led_frame_destroy(frame);
/* destroy config */
led_setup_destroy(setup);
/* destroy config */
led_prefs_deinit(prefs);
return res;
}
PAM_EXTERN int
pam_sm_acct_mgmt(pam_handle_t *pamh,
int flags,
int argc,
const char **argv)
{
struct options *opts;
FILE *fh;
char *username; /* username requesting access */
char *rhost; /* remote host */
char *srv; /* PAM service we're running as */
char buf[LINE_LENGTH];
int retval, action;
int is_v6 = 0;
struct locations *geo;
unsigned char gi_type;
GeoIP *gi = NULL;
#ifdef HAVE_GEOIP_010408
GeoIP *gi6 = NULL;
int is_city6_db = 0;
#endif
GeoIPRecord *rec = NULL;
opts = malloc(sizeof(struct options));
if (opts == NULL) {
pam_syslog(pamh, LOG_CRIT, "malloc error 'opts': %m");
return PAM_SERVICE_ERR;
}
opts->charset = GEOIP_CHARSET_UTF8;
opts->debug = 0;
opts->action = PAM_PERM_DENIED;
opts->system_file = NULL;
opts->service_file = NULL;
opts->by_service = 0;
opts->geoip_db = NULL;
#ifdef HAVE_GEOIP_010408
opts->use_v6 = 0;
opts->v6_first = 0;
opts->geoip6_db = NULL;
#endif
opts->is_city_db = 0;
geo = malloc(sizeof(struct locations));
if (geo == NULL) {
pam_syslog(pamh, LOG_CRIT, "malloc error 'geo': %m");
free_opts(opts);
return PAM_SERVICE_ERR;
}
geo->country = NULL;
geo->city = NULL;
geo->next = NULL;
_parse_args(pamh, argc, argv, opts);
if (opts->system_file == NULL)
opts->system_file = strdup(SYSTEM_FILE);
if (opts->system_file == NULL) {
pam_syslog(pamh, LOG_CRIT, "malloc error 'opts->system_file': %m");
free_opts(opts);
return PAM_SERVICE_ERR;
}
if (opts->geoip_db == NULL)
opts->geoip_db = strdup(GEOIPDB_FILE);
if (opts->geoip_db == NULL) {
pam_syslog(pamh, LOG_CRIT, "malloc error 'opts->geoip_db': %m");
free_opts(opts);
return PAM_SERVICE_ERR;
}
#ifdef HAVE_GEOIP_010408
if (opts->geoip6_db == NULL)
opts->geoip6_db = strdup(GEOIP6DB_FILE);
if (opts->geoip6_db == NULL) {
pam_syslog(pamh, LOG_CRIT, "malloc error 'opts->geoip6_db': %m");
free_opts(opts);
return PAM_SERVICE_ERR;
}
#endif
retval = pam_get_item(pamh, PAM_USER, (void*) &username);
if (username == NULL || retval != PAM_SUCCESS) {
pam_syslog(pamh, LOG_CRIT, "error recovering username");
free_opts(opts);
free_locations(geo);
return PAM_SERVICE_ERR;
}
retval = pam_get_item(pamh, PAM_RHOST, (void*) &rhost);
if (retval != PAM_SUCCESS) {
pam_syslog(pamh, LOG_CRIT, "error fetching rhost");
free_opts(opts);
free_locations(geo);
return PAM_SERVICE_ERR;
}
if (rhost == NULL) {
pam_syslog(pamh, LOG_INFO, "rhost is NULL, allowing");
free_opts(opts);
free_locations(geo);
return PAM_SUCCESS;
}
retval = pam_get_item(pamh, PAM_SERVICE, (void*) &srv);
if (srv == NULL || retval != PAM_SUCCESS ) {
pam_syslog(pamh, LOG_CRIT, "error requesting service name");
free_opts(opts);
free_locations(geo);
return PAM_SERVICE_ERR;
}
opts->service_file = malloc(PATH_MAX);
if (opts->service_file == NULL) {
pam_syslog(pamh, LOG_CRIT, "malloc error 'service_file': %m");
free_opts(opts);
free_locations(geo);
return PAM_SERVICE_ERR;
}
if (snprintf(opts->service_file, PATH_MAX-1, SERVICE_FILE, srv) < 0) {
pam_syslog(pamh, LOG_CRIT, "snprintf error 'service_file'");
free_opts(opts);
free_locations(geo);
return PAM_SERVICE_ERR;
}
gi = GeoIP_open(opts->geoip_db, GEOIP_INDEX_CACHE);
if (gi == NULL) {
pam_syslog(pamh, LOG_CRIT,
"failed to open geoip db (%s): %m", opts->geoip_db);
free_opts(opts);
free_locations(geo);
return PAM_SERVICE_ERR;
}
gi_type = GeoIP_database_edition(gi);
if (opts->debug)
pam_syslog(pamh, LOG_DEBUG, "GeoIP edition: %d", gi_type);
switch (gi_type) {
case GEOIP_COUNTRY_EDITION:
if (opts->debug)
pam_syslog(pamh, LOG_DEBUG, "GeoIP v4 edition: country");
opts->is_city_db = 0;
break;
case GEOIP_CITY_EDITION_REV0:
if (opts->debug)
pam_syslog(pamh, LOG_DEBUG, "GeoIP v4 edition: city rev0");
opts->is_city_db = 1;
break;
case GEOIP_CITY_EDITION_REV1:
if (opts->debug)
pam_syslog(pamh, LOG_DEBUG, "GeoIP v4 edition: city rev1");
opts->is_city_db = 1;
break;
default:
pam_syslog(pamh, LOG_CRIT, "invalid GeoIP DB type `%d' found", gi_type);
GeoIP_delete(gi);
free_opts(opts);
free_locations(geo);
return PAM_SERVICE_ERR;
}
GeoIP_set_charset(gi, opts->charset);
if (opts->debug)
pam_syslog(pamh, LOG_DEBUG, "GeoIP DB is City: %s",
opts->is_city_db ? "yes" : "no");
#ifdef HAVE_GEOIP_010408
if (opts->use_v6 != 0) {
gi6 = GeoIP_open(opts->geoip6_db, GEOIP_INDEX_CACHE);
if (gi6 == NULL) {
pam_syslog(pamh, LOG_CRIT,
"failed to open geoip6 db (%s): %m", opts->geoip6_db);
GeoIP_delete(gi);
free_opts(opts);
free_locations(geo);
return PAM_SERVICE_ERR;
}
gi_type = GeoIP_database_edition(gi6);
switch (gi_type) {
case GEOIP_COUNTRY_EDITION_V6:
if (opts->debug)
pam_syslog(pamh, LOG_DEBUG, "GeoIP v6 edition: country");
is_city6_db = 0;
break;
case GEOIP_CITY_EDITION_REV0_V6:
if (opts->debug)
pam_syslog(pamh, LOG_DEBUG, "GeoIP v6 edition: city rev0");
is_city6_db = 1;
break;
case GEOIP_CITY_EDITION_REV1_V6:
if (opts->debug)
pam_syslog(pamh, LOG_DEBUG, "GeoIP v6 edition: city rev1");
is_city6_db = 1;
break;
default:
pam_syslog(pamh, LOG_CRIT, "invalid GeoIP DB type `%d' found", gi_type);
GeoIP_delete(gi);
GeoIP_delete(gi6);
free_opts(opts);
free_locations(geo);
return PAM_SERVICE_ERR;
}
if (opts->debug)
pam_syslog(pamh, LOG_DEBUG, "GeoIP DB is City v6: %s",
is_city6_db ? "yes" : "no");
GeoIP_set_charset(gi6, opts->charset);
if (opts->is_city_db != is_city6_db) {
pam_syslog(pamh, LOG_CRIT, "IPv4 DB type is not the same as IPv6 (not both Country edition or both City edition)");
GeoIP_delete(gi);
GeoIP_delete(gi6);
free_opts(opts);
free_locations(geo);
return PAM_SERVICE_ERR;
}
if (opts->v6_first != 0) {
rec = GeoIP_record_by_name_v6(gi6, rhost);
if (rec == NULL) {
if (opts->debug)
pam_syslog(pamh, LOG_DEBUG, "no IPv6 record for %s, trying IPv4", rhost);
rec = GeoIP_record_by_name(gi, rhost);
}
else
is_v6 = 1;
}
else {
rec = GeoIP_record_by_name(gi, rhost);
if (rec == NULL) {
if (opts->debug)
pam_syslog(pamh, LOG_DEBUG, "no IPv4 record for %s, trying IPv6", rhost);
rec = GeoIP_record_by_name_v6(gi6, rhost);
if (rec != NULL)
is_v6 = 1;
}
}
}
else
#endif /* HAVE_GEOIP_010408 */
rec = GeoIP_record_by_name(gi, rhost);
if (rec == NULL) {
pam_syslog(pamh, LOG_INFO, "no record for %s, setting GeoIP to 'UNKNOWN,*'", rhost);
geo->city = strdup("*");
geo->country = strdup("UNKNOWN");
if (geo->city == NULL || geo->country == NULL) {
pam_syslog(pamh, LOG_CRIT, "malloc error 'geo->{city,country}': %m");
GeoIP_delete(gi);
#ifdef HAVE_GEOIP_010408
GeoIP_delete(gi6);
#endif
free_opts(opts);
free_locations(geo);
return PAM_SERVICE_ERR;
}
}
else {
if (rec->city == NULL || opts->is_city_db == 0)
geo->city = strdup("*");
else
geo->city = strdup(rec->city);
if (rec->country_code == NULL)
geo->country = strdup("UNKNOWN");
else
geo->country = strdup(rec->country_code);
if (geo->city == NULL || geo->country == NULL) {
pam_syslog(pamh, LOG_CRIT, "malloc error 'geo->{city,country}': %m");
GeoIP_delete(gi);
#ifdef HAVE_GEOIP_010408
GeoIP_delete(gi6);
#endif
free_opts(opts);
free_locations(geo);
return PAM_SERVICE_ERR;
}
if (opts->is_city_db) {
geo->latitude = rec->latitude;
geo->longitude = rec->longitude;
}
}
if (opts->debug)
pam_syslog(pamh, LOG_DEBUG, "GeoIP record for %s: %s,%s",
rhost, geo->country, geo->city);
if (opts->debug && strcmp(geo->country, "UNKNOWN") != 0 && opts->is_city_db)
pam_syslog(pamh, LOG_DEBUG, "GeoIP coordinates for %s: %f,%f",
rhost, geo->latitude, geo->longitude);
if ((fh = fopen(opts->service_file, "r")) != NULL) {
opts->by_service = 1;
if (opts->debug)
pam_syslog(pamh, LOG_DEBUG, "using services file %s",
opts->service_file);
}
else {
if ((fh = fopen(opts->system_file, "r")) == NULL) {
pam_syslog(pamh, LOG_CRIT, "error opening %s: %m", opts->system_file);
#ifdef HAVE_GEOIP_010408
if (gi6) GeoIP_delete(gi6);
#endif
if (gi) GeoIP_delete(gi);
if (rec) GeoIPRecord_delete(rec);
free_opts(opts);
return PAM_SERVICE_ERR;
}
}
action = opts->action;
char location[LINE_LENGTH];
while (fgets(buf, LINE_LENGTH, fh) != NULL) {
char *line, *ptr;
char domain[LINE_LENGTH],
service[LINE_LENGTH];
action = opts->action;
line = buf;
/* skip the leading white space */
while (*line && isspace(*line))
line++;
/* Rip off the comments */
ptr = strchr(line,'#');
if (ptr)
*ptr = '\0';
/* Rip off the newline char */
ptr = strchr(line,'\n');
if (ptr)
*ptr = '\0';
/* Anything left ? */
if (!strlen(line))
continue;
if (opts->by_service)
action = parse_line_srv(pamh, line, domain, location);
else
action = parse_line_sys(pamh, line, domain, service, location);
if (action < 0) { /* parsing failed */
action = opts->action;
continue;
}
if (!opts->by_service) {
if (!check_service(pamh, service, srv))
continue;
}
if ((strcmp(domain, "*") == 0) || (strcmp(username, domain) == 0)) {
if (check_location(pamh, opts, location, geo))
break;
}
else if (domain[0] == '@') {
if (pam_modutil_user_in_group_nam_nam(pamh, username, domain+1)) {
if (check_location(pamh, opts, location, geo))
break;
}
}
}
fclose(fh);
if (gi) GeoIP_delete(gi);
#ifdef HAVE_GEOIP_010408
if (gi6) GeoIP_delete(gi6);
#endif
if (rec) GeoIPRecord_delete(rec);
free_locations(geo);
switch (action) {
case PAM_SUCCESS:
pam_syslog(pamh, LOG_DEBUG, "location %s allowed for user %s from %s (IPv%d)", location, username, rhost, is_v6 ? 6 : 4);
break;
case PAM_PERM_DENIED:
pam_syslog(pamh, LOG_DEBUG, "location %s denied for user %s from %s (IPv%d)", location, username, rhost, is_v6 ? 6 : 4);
break;
case PAM_IGNORE:
pam_syslog(pamh, LOG_DEBUG, "location %s ignored for user %s from %s (IPv%d)", location, username, rhost, is_v6 ? 6 : 4);
break;
default: /* should not happen */
pam_syslog(pamh, LOG_DEBUG, "location status: %d, IPv%d", action, is_v6 ? 6 : 4);
break;
};
free_opts(opts);
return action;
}
