static int nand_init(struct command_context *cmd_ctx)
{
if (!nand_devices)
return ERROR_OK;
struct command *parent = command_find_in_context(cmd_ctx, "nand");
return register_commands(cmd_ctx, parent, nand_exec_command_handlers);
}
static int swd_select(struct command_context *ctx)
{
struct target *target = get_current_target(ctx);
int retval;
retval = register_commands(ctx, NULL, swd_handlers);
if (retval != ERROR_OK)
return retval;
/* be sure driver is in SWD mode; start
* with hardware default TRN (1), it can be changed later
*/
if (!swd || !swd->read_reg || !swd->write_reg || !swd->init) {
LOG_DEBUG("no SWD driver?");
return ERROR_FAIL;
}
retval = swd->init(1);
if (retval != ERROR_OK) {
LOG_DEBUG("can't init SWD driver");
return retval;
}
/* force DAP into SWD mode (not JTAG) */
retval = dap_to_swd(target);
return retval;
}
static int
standard_session(const char* device, const char* fsName, bool interactive)
{
// mount FS
fssh_dev_t fsDev = _kern_mount(kMountPoint, device, fsName, 0, NULL, 0);
if (fsDev < 0) {
fprintf(stderr, "Error: Mounting FS failed: %s\n",
fssh_strerror(fsDev));
return 1;
}
// register commands
register_commands();
// process commands
input_loop(interactive);
// unmount FS
_kern_setcwd(-1, "/"); // avoid a "busy" vnode
fssh_status_t error = _kern_unmount(kMountPoint, 0);
if (error != FSSH_B_OK) {
fprintf(stderr, "Error: Unmounting FS failed: %s\n",
fssh_strerror(error));
return 1;
}
return 0;
}
static int swd_select(struct command_context *ctx)
{
/* FIXME: only place where global 'jtag_interface' is still needed */
extern struct jtag_interface *jtag_interface;
const struct swd_driver *swd = jtag_interface->swd;
int retval;
retval = register_commands(ctx, NULL, swd_handlers);
if (retval != ERROR_OK)
return retval;
/* be sure driver is in SWD mode; start
* with hardware default TRN (1), it can be changed later
*/
if (!swd || !swd->read_reg || !swd->write_reg || !swd->init) {
LOG_DEBUG("no SWD driver?");
return ERROR_FAIL;
}
retval = swd->init();
if (retval != ERROR_OK) {
LOG_DEBUG("can't init SWD driver");
return retval;
}
return retval;
}
int register_commands(struct command_context *cmd_ctx, struct command *parent,
const struct command_registration *cmds)
{
int retval = ERROR_OK;
unsigned i;
for (i = 0; cmds[i].name || cmds[i].chain; i++) {
const struct command_registration *cr = cmds + i;
struct command *c = NULL;
if (NULL != cr->name) {
c = register_command(cmd_ctx, parent, cr);
if (NULL == c) {
retval = ERROR_FAIL;
break;
}
}
if (NULL != cr->chain) {
struct command *p = c ? : parent;
retval = register_commands(cmd_ctx, p, cr->chain);
if (ERROR_OK != retval)
break;
}
}
if (ERROR_OK != retval) {
for (unsigned j = 0; j < i; j++)
unregister_command(cmd_ctx, parent, cmds[j].name);
}
return retval;
}
static int cmsis_dap_select(struct command_context *ctx)
{
LOG_DEBUG("CMSIS-ADI: cmsis_dap_select");
int retval = register_commands(ctx, NULL, cmsis_dap_handlers);
if (retval != ERROR_OK)
return retval;
/* FIXME: This needs a real overhaul!! FIXME
* be sure driver is in SWD mode; start
* with hardware default TRN (1), it can be changed later
* we use a bogus 'swd' driver to implement cmsis-dap as it is quite similar */
const struct swd_driver *swd = jtag_interface->swd;
if (!swd || !swd->read_reg || !swd->write_reg || !swd->init) {
LOG_ERROR("no SWD driver?");
return ERROR_FAIL;
}
retval = swd->init(1);
if (retval != ERROR_OK) {
LOG_ERROR("unable to init CMSIS-DAP driver");
return retval;
}
return retval;
}
static COMMAND_HELPER(create_nand_device, const char *bank_name,
struct nand_flash_controller *controller)
{
struct nand_device *c;
struct target *target;
int retval;
if (CMD_ARGC < 2)
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
target = get_target(CMD_ARGV[1]);
if (!target) {
LOG_ERROR("invalid target %s", CMD_ARGV[1]);
return ERROR_COMMAND_ARGUMENT_INVALID;
}
if (NULL != controller->commands)
{
retval = register_commands(CMD_CTX, NULL,
controller->commands);
if (ERROR_OK != retval)
return retval;
}
c = malloc(sizeof(struct nand_device));
if (c == NULL)
{
LOG_ERROR("End of memory");
return ERROR_FAIL;
}
c->name = strdup(bank_name);
c->target = target;
c->controller = controller;
c->controller_priv = NULL;
c->manufacturer = NULL;
c->device = NULL;
c->bus_width = 0;
c->address_cycles = 0;
c->page_size = 0;
c->use_raw = 0;
c->next = NULL;
retval = CALL_COMMAND_HANDLER(controller->nand_device_command, c);
if (ERROR_OK != retval)
{
assert(controller->usage != NULL);
LOG_ERROR("'%s' driver rejected nand flash. Usage: %s",
controller->name,
controller->usage);
free(c);
return retval;
}
nand_device_add(c);
return ERROR_OK;
}
int server_register_commands(struct command_context *cmd_ctx)
{
int retval = telnet_register_commands(cmd_ctx);
if (ERROR_OK != retval)
return retval;
retval = tcl_register_commands(cmd_ctx);
if (ERROR_OK != retval)
return retval;
return register_commands(cmd_ctx, NULL, server_command_handlers);
}
void mod_db_sql_init() {
char *str;
mod_db_sql_config.host = XSTRDUP("127.0.0.1", "mod_db_sql_init");
mod_db_sql_config.db = XSTRDUP("netmush", "mod_db_sql_init");
mod_db_sql_config.username = XSTRDUP("netmush", "mod_db_sql_init");
mod_db_sql_config.password = XSTRDUP("netmush", "mod_db_sql_init");
mod_db_sql_config.reconnect = 1;
mod_db_sql_config.port = 3306;
str = XMALLOC(MBUF_SIZE, "mod_db_sql_init");
snprintf(str, MBUF_SIZE, "version %d.%d", mudstate.version.major, mudstate.version.minor);
switch(mudstate.version.status){
case 0:
snprintf(str, MBUF_SIZE, "%s, Alpha %d", str, mudstate.version.revision);
break;
case 1:
snprintf(str, MBUF_SIZE, "%s, Beta %d", str, mudstate.version.revision);
break;
case 2:
snprintf(str, MBUF_SIZE, "%s, Release Candidate %d", str, mudstate.version.revision);
break;
default:
if(mudstate.version.revision > 0) {
snprintf(str, MBUF_SIZE, "%s, Patch Level %d", str, mudstate.version.revision);
} else {
snprintf(str, MBUF_SIZE, "%s, Gold Release.", str);
}
}
#ifdef SQL_DRIVER
snprintf(str, MBUF_SIZE, "%s (%s) using %s driver", str , PACKAGE_RELEASE_DATE, SQL_DRIVER);
mod_db_sql_version.version=XSTRDUP( str , "mod_db_sql_init");
#else
snprintf(str, MBUF_SIZE, "%s (%s) using placeholder driver", str , PACKAGE_RELEASE_DATE);
mod_db_sql_version.version=XSTRDUP(str, "mod_db_sql_init");
#endif
mod_db_sql_version.author=XSTRDUP("TinyMUSH Development Team", "mod_db_sql_init");
mod_db_sql_version.email=XSTRDUP("*****@*****.**", "mod_db_sql_init");
mod_db_sql_version.url=XSTRDUP("http://sourceforge.net/projects/tinymush/", "mod_db_sql_init");
mod_db_sql_version.description=XSTRDUP("SQL Database interface for TinyMUSH", "mod_db_sql_init");
mod_db_sql_version.copyright=XSTRDUP("Copyright (C) 2012 TinyMUSH development team.", "mod_db_sql_init");
XFREE(str, "mod_db_sql_init");
register_commands(mod_db_sql_cmdtable);
register_functions(mod_db_sql_functable);
}
void
initialize_data (void)
{
if (initialized)
return;
initialized = TRUE;
ProgramsCache = g_hash_table_new_full (g_str_hash,
g_str_equal,
g_free,
NULL);
migrate_options_directory ();
register_commands ();
compute_supported_archive_types ();
fr_stock_init ();
}
static void
server (void)
{
int rc;
assuan_context_t ctx;
log_info ("server started\n");
rc = assuan_new (&ctx);
if (rc)
log_fatal ("assuan_new failed: %s\n", gpg_strerror (rc));
rc = assuan_init_pipe_server (ctx, NULL);
if (rc)
log_fatal ("assuan_init_pipe_server failed: %s\n", gpg_strerror (rc));
rc = register_commands (ctx);
if (rc)
log_fatal ("register_commands failed: %s\n", gpg_strerror(rc));
assuan_set_log_stream (ctx, stderr);
for (;;)
{
rc = assuan_accept (ctx);
if (rc)
{
if (rc != -1)
log_error ("assuan_accept failed: %s\n", gpg_strerror (rc));
break;
}
log_info ("client connected. Client's pid is %ld\n",
(long)assuan_get_pid (ctx));
rc = assuan_process (ctx);
if (rc)
log_error ("assuan_process failed: %s\n", gpg_strerror (rc));
}
assuan_release (ctx);
}
int main()
{
char* input;
register_commands();
while (1) {
input = readline("$> ");
if ( ! input)
break;
if (strlen(input) > 0) {
add_history(input);
}
List* cmd_line = parse_line(input);
run_line(cmd_line);
free(input);
}
return 0;
}
void
GameEvent(CORE_DATA *cd)
{
switch (cd->event) {
case EVENT_START:
RegisterPlugin(OPENCORE_VERSION, CORE_NAME, "cycad", OPENCORE_VERSION, __DATE__, __TIME__, "core handler", 0, 0);
register_commands();
break;
case EVENT_COMMAND:
switch (cd->cmd_id) {
case CMD_DIE: cmd_die(cd); break;
case CMD_STOPBOT: cmd_stopbot(cd); break;
case CMD_GETFILE: cmd_getfile(cd); break;
case CMD_PUTFILE: cmd_putfile(cd); break;
case CMD_LISTBOTS: cmd_listbots(cd); break;
case CMD_TYPES: cmd_types(cd); break;
case CMD_LOADTYPES: cmd_loadtypes(cd); break;
case CMD_LOG: cmd_log(cd); break;
case CMD_CMDLOG: cmd_cmdlog(cd); break;
case CMD_ABOUT: cmd_about(cd); break;
case CMD_INSLIB: cmd_inslib(cd); break;
case CMD_RMLIB: cmd_rmlib(cd); break;
case CMD_HELP: cmd_help(cd); break;
case CMD_SYSINFO: cmd_sysinfo(cd); break;
case CMD_LOADOPS: cmd_loadops(cd); break;
case CMD_LISTOPS: cmd_listops(cd); break;
case CMD_EXEC: cmd_exec(cd); break;
case CMD_STARTBOT: cmd_startbot(cd); break;
case CMD_GO: cmd_go(cd); break;
default: break;
}
break;
default:
break;
}
}
int jsp_register_commands(struct command_context *cmd_ctx)
{
jsp_port = strdup("7777");
return register_commands(cmd_ctx, NULL, jsp_command_handlers);
}
static int openocd_register_commands(struct command_context *cmd_ctx)
{
return register_commands(cmd_ctx, NULL, openocd_command_handlers);
}
int main( int argc, char* argv[] )
{
/* Information about the current video settings. */
const SDL_VideoInfo* info = NULL;
g_Time = InitTime();
/* First, initialize SDL's video subsystem. */
if( SDL_Init( SDL_INIT_VIDEO ) < 0 ) {
/* Failed, exit. */
fprintf( stderr, "Video initialization failed: %s\n",
SDL_GetError( ) );
quit_tutorial( 1 );
}
/* Let's get some video information. */
info = SDL_GetVideoInfo( );
if( !info ) {
/* This should probably never happen. */
fprintf( stderr, "Video query failed: %s\n",
SDL_GetError( ) );
quit_tutorial( 1 );
}
g_bpp = info->vfmt->BitsPerPixel;
SDL_GL_SetAttribute( SDL_GL_RED_SIZE, 8 );
SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, 8 );
SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, 8 );
SDL_GL_SetAttribute( SDL_GL_ALPHA_SIZE, 8);
SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16 );
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
g_flags = SDL_OPENGL|SDL_HWPALETTE|/*SDL_NOFRAME|*/SDL_HWSURFACE/*|SDL_RESIZABLE*//*| SDL_FULLSCREEN*/;
/*
* Set the video mode
*/
if( SDL_SetVideoMode( g_width, g_height, g_bpp, g_flags ) == 0 ) {
/*
* This could happen for a variety of reasons,
* including DISPLAY not being set, the specified
* resolution not being available, etc.
*/
fprintf( stderr, "Video mode set failed: %s\n",
SDL_GetError( ) );
quit_tutorial( 1 );
}
/*
* At this point, we should have a properly setup
* double-buffered window for use with OpenGL.
*/
setup_opengl( g_width, g_height );
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
quit_tutorial(1);
}
fprintf(stdout, "Status: Using GLEW %s\n", glewGetString(GLEW_VERSION));
if (!GLEW_ARB_vertex_program || !GLEW_ARB_vertex_program)
{
fprintf(stderr, "No shader program support\n");
quit_tutorial(1);
}
if (glewIsSupported("GL_VERSION_2_0"))
printf("Ready for OpenGL 2.0\n");
else {
printf("OpenGL 2.0 not supported\n");
quit_tutorial(1);
}
/*
* Init OpenGL text driver which will
* be used by GraphicsConsole
*/
g_pTextDriver = new OGLTextDriver();
if( false == g_pTextDriver->init("FixedWidth.bmp", 8, 16, 16, g_width, g_height))
quit_tutorial( 1 );
register_commands();
GraphicsConsole::Instance().setTextDriver(g_pTextDriver);
SDL_EnableKeyRepeat(500, 30);
draw_velocity = glsl_program::makeProgram("drawVelocity", DATA_PATH"quad.vs", DATA_PATH"draw_velocity.fs");
draw_fluids = glsl_program::makeProgram("drawFluids", DATA_PATH"quad.vs", DATA_PATH"draw_fluids.fs");
assert(draw_velocity);
start_time = time(0);
g_fluids.createShaders();
g_fluids.createBuffers();
UI::Init(g_width, g_height);
g_fluids.createUI();
SDL_WM_SetCaption("console", 0);
/*
* Now we want to begin our normal app process--
* an event loop with a lot of redrawing.
*/
while( !g_exit ) {
UpdateTime(&g_Time);
/* Process incoming events. */
process_events( );
/* Draw the screen. */
draw_screen( );
}
quit_tutorial(0);
return 0;
}
int tcl_register_commands(struct command_context *cmd_ctx)
{
tcl_port = strdup("6666");
return register_commands(cmd_ctx, NULL, tcl_command_handlers);
}
static int stlink_transport_register_commands(struct command_context *cmd_ctx)
{
return register_commands(cmd_ctx, NULL,
stlink_transport_command_handlers);
}
/* Startup the server. CTRL must have been allocated by the caller
and set to the default values. */
int
gpg_server (ctrl_t ctrl)
{
int rc;
#ifndef HAVE_W32_SYSTEM
int filedes[2];
#endif
assuan_context_t ctx = NULL;
static const char hello[] = ("GNU Privacy Guard's OpenPGP server "
VERSION " ready");
/* We use a pipe based server so that we can work from scripts.
assuan_init_pipe_server will automagically detect when we are
called with a socketpair and ignore FILEDES in this case. */
#ifndef HAVE_W32_SYSTEM
filedes[0] = assuan_fdopen (0);
filedes[1] = assuan_fdopen (1);
#endif
rc = assuan_new (&ctx);
if (rc)
{
log_error ("failed to allocate the assuan context: %s\n",
gpg_strerror (rc));
goto leave;
}
#ifdef HAVE_W32_SYSTEM
rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
#else
rc = assuan_init_pipe_server (ctx, filedes);
#endif
if (rc)
{
log_error ("failed to initialize the server: %s\n", gpg_strerror (rc));
goto leave;
}
rc = register_commands (ctx);
if (rc)
{
log_error ("failed to the register commands with Assuan: %s\n",
gpg_strerror(rc));
goto leave;
}
assuan_set_pointer (ctx, ctrl);
if (opt.verbose || opt.debug)
{
char *tmp = NULL;
tmp = xtryasprintf ("Home: %s\n"
"Config: %s\n"
"%s",
opt.homedir,
"fixme: need config filename",
hello);
if (tmp)
{
assuan_set_hello_line (ctx, tmp);
xfree (tmp);
}
}
else
assuan_set_hello_line (ctx, hello);
assuan_register_reset_notify (ctx, reset_notify);
assuan_register_input_notify (ctx, input_notify);
assuan_register_output_notify (ctx, output_notify);
assuan_register_option_handler (ctx, option_handler);
ctrl->server_local = xtrycalloc (1, sizeof *ctrl->server_local);
if (!ctrl->server_local)
{
rc = gpg_error_from_syserror ();
goto leave;
}
ctrl->server_local->assuan_ctx = ctx;
ctrl->server_local->message_fd = GNUPG_INVALID_FD;
for (;;)
{
rc = assuan_accept (ctx);
if (rc == -1)
{
rc = 0;
break;
}
else if (rc)
{
log_info ("Assuan accept problem: %s\n", gpg_strerror (rc));
break;
}
rc = assuan_process (ctx);
if (rc)
{
log_info ("Assuan processing failed: %s\n", gpg_strerror (rc));
continue;
}
}
leave:
if (ctrl->server_local)
{
release_pk_list (ctrl->server_local->recplist);
xfree (ctrl->server_local);
ctrl->server_local = NULL;
}
assuan_release (ctx);
return rc;
}
bool w_start_listener(const char *path)
{
struct sockaddr_un un;
pthread_t thr;
pthread_attr_t attr;
pthread_mutexattr_t mattr;
struct sigaction sa;
sigset_t sigset;
#ifdef HAVE_LIBGIMLI_H
volatile struct gimli_heartbeat *hb = NULL;
#endif
pthread_mutexattr_init(&mattr);
pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&w_client_lock, &mattr);
pthread_mutexattr_destroy(&mattr);
#ifdef HAVE_LIBGIMLI_H
hb = gimli_heartbeat_attach();
#endif
#ifdef HAVE_KQUEUE
{
struct rlimit limit;
int mib[2] = { CTL_KERN,
#ifdef KERN_MAXFILESPERPROC
KERN_MAXFILESPERPROC
#else
KERN_MAXFILES
#endif
};
int maxperproc;
size_t len;
len = sizeof(maxperproc);
sysctl(mib, 2, &maxperproc, &len, NULL, 0);
getrlimit(RLIMIT_NOFILE, &limit);
w_log(W_LOG_ERR, "file limit is %" PRIu64
" kern.maxfilesperproc=%i\n",
limit.rlim_cur, maxperproc);
if (limit.rlim_cur != RLIM_INFINITY &&
maxperproc > 0 &&
limit.rlim_cur < (rlim_t)maxperproc) {
limit.rlim_cur = maxperproc;
if (setrlimit(RLIMIT_NOFILE, &limit)) {
w_log(W_LOG_ERR,
"failed to raise limit to %" PRIu64 " (%s).\n",
limit.rlim_cur,
strerror(errno));
} else {
w_log(W_LOG_ERR,
"raised file limit to %" PRIu64 "\n",
limit.rlim_cur);
}
}
getrlimit(RLIMIT_NOFILE, &limit);
if (limit.rlim_cur < 10240) {
w_log(W_LOG_ERR,
"Your file descriptor limit is very low (%" PRIu64 "), "
"please consult the watchman docs on raising the limits\n",
limit.rlim_cur);
}
}
#endif
if (strlen(path) >= sizeof(un.sun_path) - 1) {
w_log(W_LOG_ERR, "%s: path is too long\n",
path);
return false;
}
signal(SIGPIPE, SIG_IGN);
/* allow SIGUSR1 and SIGCHLD to wake up a blocked thread, without restarting
* syscalls */
memset(&sa, 0, sizeof(sa));
sa.sa_handler = wakeme;
sa.sa_flags = 0;
sigaction(SIGUSR1, &sa, NULL);
sigaction(SIGCHLD, &sa, NULL);
// Block SIGCHLD everywhere
sigemptyset(&sigset);
sigaddset(&sigset, SIGCHLD);
sigprocmask(SIG_BLOCK, &sigset, NULL);
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
listener_fd = socket(PF_LOCAL, SOCK_STREAM, 0);
if (listener_fd == -1) {
w_log(W_LOG_ERR, "socket: %s\n",
strerror(errno));
return false;
}
un.sun_family = PF_LOCAL;
strcpy(un.sun_path, path);
if (bind(listener_fd, (struct sockaddr*)&un, sizeof(un)) != 0) {
w_log(W_LOG_ERR, "bind(%s): %s\n",
path, strerror(errno));
close(listener_fd);
return false;
}
if (listen(listener_fd, 200) != 0) {
w_log(W_LOG_ERR, "listen(%s): %s\n",
path, strerror(errno));
close(listener_fd);
return false;
}
w_set_cloexec(listener_fd);
if (pthread_create(&reaper_thread, NULL, child_reaper, NULL)) {
w_log(W_LOG_FATAL, "pthread_create(reaper): %s\n",
strerror(errno));
return false;
}
if (!clients) {
clients = w_ht_new(2, &client_hash_funcs);
}
// Wire up the command handlers
register_commands(commands);
w_state_load();
#ifdef HAVE_LIBGIMLI_H
if (hb) {
gimli_heartbeat_set(hb, GIMLI_HB_RUNNING);
}
w_set_nonblock(listener_fd);
#endif
// Now run the dispatch
while (true) {
int client_fd;
struct watchman_client *client;
struct pollfd pfd;
int bufsize;
#ifdef HAVE_LIBGIMLI_H
if (hb) {
gimli_heartbeat_set(hb, GIMLI_HB_RUNNING);
}
#endif
pfd.events = POLLIN;
pfd.fd = listener_fd;
poll(&pfd, 1, 10000);
client_fd = accept(listener_fd, NULL, 0);
if (client_fd == -1) {
continue;
}
w_set_cloexec(client_fd);
bufsize = WATCHMAN_IO_BUF_SIZE;
setsockopt(client_fd, SOL_SOCKET, SO_SNDBUF, &bufsize, sizeof(bufsize));
client = calloc(1, sizeof(*client));
client->fd = client_fd;
if (!w_json_buffer_init(&client->reader)) {
// FIXME: error handling
}
if (!w_json_buffer_init(&client->writer)) {
// FIXME: error handling
}
if (pipe(client->ping)) {
// FIXME: error handling
}
client->subscriptions = w_ht_new(2, &subscription_hash_funcs);
w_set_cloexec(client->ping[0]);
w_set_nonblock(client->ping[0]);
w_set_cloexec(client->ping[1]);
w_set_nonblock(client->ping[1]);
pthread_mutex_lock(&w_client_lock);
w_ht_set(clients, client->fd, (w_ht_val_t)client);
pthread_mutex_unlock(&w_client_lock);
// Start a thread for the client.
// We used to use libevent for this, but we have
// a low volume of concurrent clients and the json
// parse/encode APIs are not easily used in a non-blocking
// server architecture.
if (pthread_create(&thr, &attr, client_thread, client)) {
// It didn't work out, sorry!
pthread_mutex_lock(&w_client_lock);
w_ht_del(clients, client->fd);
pthread_mutex_unlock(&w_client_lock);
}
}
pthread_attr_destroy(&attr);
return true;
}
int trace_register_commands(struct command_context *cmd_ctx)
{
return register_commands(cmd_ctx, NULL, trace_command_handlers);
}
int
pinentry_loop2 (int infd, int outfd)
{
int rc;
int filedes[2];
ASSUAN_CONTEXT ctx;
/* Extra check to make sure we have dropped privs. */
#ifndef HAVE_DOSISH_SYSTEM
if (getuid() != geteuid())
abort ();
#endif
/* For now we use a simple pipe based server so that we can work
from scripts. We will later add options to run as a daemon and
wait for requests on a Unix domain socket. */
filedes[0] = infd;
filedes[1] = outfd;
rc = assuan_init_pipe_server (&ctx, filedes);
if (rc)
{
fprintf (stderr, "%s: failed to initialize the server: %s\n",
this_pgmname, assuan_strerror(rc));
return -1;
}
rc = register_commands (ctx);
if (rc)
{
fprintf (stderr, "%s: failed to the register commands with Assuan: %s\n",
this_pgmname, assuan_strerror(rc));
return -1;
}
assuan_register_option_handler (ctx, option_handler);
#if 0
assuan_set_log_stream (ctx, stderr);
#endif
for (;;)
{
rc = assuan_accept (ctx);
if (rc == -1)
break;
else if (rc)
{
fprintf (stderr, "%s: Assuan accept problem: %s\n",
this_pgmname, assuan_strerror (rc));
break;
}
rc = assuan_process (ctx);
if (rc)
{
fprintf (stderr, "%s: Assuan processing failed: %s\n",
this_pgmname, assuan_strerror (rc));
continue;
}
}
assuan_deinit_server (ctx);
return 0;
}
int transport_register_commands(struct command_context *ctx)
{
return register_commands(ctx, NULL, transport_group);
}
int ioutil_init(struct command_context *cmd_ctx)
{
return register_commands(cmd_ctx, NULL, ioutil_command_handlers);
}
/* Startup the server. DEFAULT_RECPLIST is the list of recipients as
set from the command line or config file. We only require those
marked as encrypt-to. */
void
gpgsm_server (certlist_t default_recplist)
{
int rc;
assuan_fd_t filedes[2];
assuan_context_t ctx;
struct server_control_s ctrl;
static const char hello[] = ("GNU Privacy Guard's S/M server "
VERSION " ready");
memset (&ctrl, 0, sizeof ctrl);
gpgsm_init_default_ctrl (&ctrl);
/* We use a pipe based server so that we can work from scripts.
assuan_init_pipe_server will automagically detect when we are
called with a socketpair and ignore FILEDES in this case. */
#ifdef HAVE_W32CE_SYSTEM
#define SERVER_STDIN es_fileno(es_stdin)
#define SERVER_STDOUT es_fileno(es_stdout)
#else
#define SERVER_STDIN 0
#define SERVER_STDOUT 1
#endif
filedes[0] = assuan_fdopen (SERVER_STDIN);
filedes[1] = assuan_fdopen (SERVER_STDOUT);
rc = assuan_new (&ctx);
if (rc)
{
log_error ("failed to allocate assuan context: %s\n",
gpg_strerror (rc));
gpgsm_exit (2);
}
rc = assuan_init_pipe_server (ctx, filedes);
if (rc)
{
log_error ("failed to initialize the server: %s\n",
gpg_strerror (rc));
gpgsm_exit (2);
}
rc = register_commands (ctx);
if (rc)
{
log_error ("failed to the register commands with Assuan: %s\n",
gpg_strerror(rc));
gpgsm_exit (2);
}
if (opt.verbose || opt.debug)
{
char *tmp = NULL;
const char *s1 = getenv ("GPG_AGENT_INFO");
if (asprintf (&tmp,
"Home: %s\n"
"Config: %s\n"
"AgentInfo: %s\n"
"DirmngrInfo: %s\n"
"%s",
opt.homedir,
opt.config_filename,
s1?s1:"[not set]",
dirmngr_socket_name (),
hello) > 0)
{
assuan_set_hello_line (ctx, tmp);
free (tmp);
}
}
else
assuan_set_hello_line (ctx, hello);
assuan_register_reset_notify (ctx, reset_notify);
assuan_register_input_notify (ctx, input_notify);
assuan_register_output_notify (ctx, output_notify);
assuan_register_option_handler (ctx, option_handler);
assuan_set_pointer (ctx, &ctrl);
ctrl.server_local = xcalloc (1, sizeof *ctrl.server_local);
ctrl.server_local->assuan_ctx = ctx;
ctrl.server_local->message_fd = -1;
ctrl.server_local->list_internal = 1;
ctrl.server_local->list_external = 0;
ctrl.server_local->default_recplist = default_recplist;
for (;;)
{
rc = assuan_accept (ctx);
if (rc == -1)
{
break;
}
else if (rc)
{
log_info ("Assuan accept problem: %s\n", gpg_strerror (rc));
break;
}
rc = assuan_process (ctx);
if (rc)
{
log_info ("Assuan processing failed: %s\n", gpg_strerror (rc));
continue;
}
}
gpgsm_release_certlist (ctrl.server_local->recplist);
ctrl.server_local->recplist = NULL;
gpgsm_release_certlist (ctrl.server_local->signerlist);
ctrl.server_local->signerlist = NULL;
xfree (ctrl.server_local);
audit_release (ctrl.audit);
ctrl.audit = NULL;
assuan_release (ctx);
}
int main( int argc, char* argv[] )
{
/* Information about the current video settings. */
const SDL_VideoInfo* info = NULL;
/* First, initialize SDL's video subsystem. */
if( SDL_Init( SDL_INIT_VIDEO ) < 0 ) {
/* Failed, exit. */
fprintf( stderr, "Video initialization failed: %s\n",
SDL_GetError( ) );
quit_tutorial( 1 );
}
/* Let's get some video information. */
info = SDL_GetVideoInfo( );
if( !info ) {
/* This should probably never happen. */
fprintf( stderr, "Video query failed: %s\n",
SDL_GetError( ) );
quit_tutorial( 1 );
}
g_bpp = info->vfmt->BitsPerPixel;
SDL_GL_SetAttribute( SDL_GL_RED_SIZE, 8 );
SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, 8 );
SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, 8 );
SDL_GL_SetAttribute( SDL_GL_ALPHA_SIZE, 8);
SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16 );
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
g_flags = SDL_OPENGL|SDL_HWPALETTE|/*SDL_NOFRAME|*/SDL_HWSURFACE/*|SDL_RESIZABLE*//*| SDL_FULLSCREEN*/;
/*
* Set the video mode
*/
if( SDL_SetVideoMode( g_width, g_height, g_bpp, g_flags ) == 0 ) {
/*
* This could happen for a variety of reasons,
* including DISPLAY not being set, the specified
* resolution not being available, etc.
*/
fprintf( stderr, "Video mode set failed: %s\n",
SDL_GetError( ) );
quit_tutorial( 1 );
}
/*
* At this point, we should have a properly setup
* double-buffered window for use with OpenGL.
*/
setup_opengl( g_width, g_height );
/*
* Init OpenGL text driver which will
* be used by GraphicsConsole
*/
g_pTextDriver = new OGLTextDriver();
if( false == g_pTextDriver->init("FixedWidth.bmp", 8, 16, 16, g_width, g_height))
quit_tutorial( 1 );
register_commands();
GraphicsConsole::Instance().setTextDriver(g_pTextDriver);
SDL_EnableKeyRepeat(500, 30);
SDL_WM_SetCaption("console", 0);
/*
* Now we want to begin our normal app process--
* an event loop with a lot of redrawing.
*/
while( !g_exit ) {
/* Process incoming events. */
process_events( );
/* Draw the screen. */
draw_screen( );
}
quit_tutorial(0);
/*
* EXERCISE:
* Record timings using SDL_GetTicks() and
* and print out frames per second at program
* end.
*/
/* Never reached. */
return 0;
}
int telnet_register_commands(struct command_context *cmd_ctx)
{
telnet_port = strdup("4444");
return register_commands(cmd_ctx, NULL, telnet_command_handlers);
}
int
main(int argc, char *argv[])
{
int ch, debug = 1, rc = EXIT_FAILURE;
const char *fmt = "plain";
lldpctl_conn_t *conn = NULL;
const char *options = is_lldpctl(argv[0])?"hdvf:":"hdsvf:c:u:";
int gotinputs = 0;
struct inputs inputs;
TAILQ_INIT(&inputs);
ctlname = lldpctl_get_default_transport();
signal(SIGHUP, SIG_IGN);
/* Initialize logging */
while ((ch = getopt(argc, argv, options)) != -1) {
switch (ch) {
case 'd': debug++; break;
case 's': debug--; break;
}
}
log_init(debug, __progname);
/* Get and parse command line options */
optind = 1;
while ((ch = getopt(argc, argv, options)) != -1) {
switch (ch) {
case 'd': break;
case 's': break;
case 'h':
usage();
break;
case 'u':
ctlname = optarg;
break;
case 'v':
fprintf(stdout, "%s\n", PACKAGE_VERSION);
exit(0);
break;
case 'f':
fmt = optarg;
break;
case 'c':
gotinputs = 1;
input_append(optarg, &inputs, 1);
break;
default:
usage();
}
}
/* Disable SIGPIPE */
signal(SIGPIPE, SIG_IGN);
/* Register commands */
root = register_commands();
/* Make a connection */
log_debug("lldpctl", "connect to lldpd");
conn = lldpctl_new_name(ctlname, NULL, NULL, NULL);
if (conn == NULL) goto end;
/* Process file inputs */
while (gotinputs && !TAILQ_EMPTY(&inputs)) {
/* coverity[use_after_free]
TAILQ_REMOVE does the right thing */
struct input *first = TAILQ_FIRST(&inputs);
log_debug("lldpctl", "process: %s", first->name);
FILE *file = fopen(first->name, "r");
if (file) {
size_t len;
char *line;
while ((line = fgetln(file, &len))) {
line = strndup(line, len);
if (line[len - 1] == '\n') {
line[len - 1] = '\0';
parse_and_exec(conn, fmt, line);
}
free(line);
}
fclose(file);
} else {
log_warn("lldpctl", "unable to open %s",
first->name);
}
TAILQ_REMOVE(&inputs, first, next);
free(first->name);
free(first);
}
/* Process additional arguments. First if we are lldpctl (interfaces) */
if (is_lldpctl(NULL)) {
char *line = NULL;
for (int i = optind; i < argc; i++) {
char *prev = line;
if (asprintf(&line, "%s%s%s",
prev?prev:"show neigh ports ", argv[i],
(i == argc - 1)?" details":",") == -1) {
log_warnx("lldpctl", "not enough memory to build list of interfaces");
free(prev);
goto end;
}
free(prev);
}
if (line == NULL && (line = strdup("show neigh details")) == NULL) {
log_warnx("lldpctl", "not enough memory to build command line");
goto end;
}
log_debug("lldpctl", "execute %s", line);
if (parse_and_exec(conn, fmt, line) != -1)
rc = EXIT_SUCCESS;
free(line);
goto end;
}
/* Then, if we are regular lldpcli (command line) */
if (optind < argc) {
const char **cargv;
int cargc;
cargv = &((const char **)argv)[optind];
cargc = argc - optind;
if (cmd_exec(conn, fmt, cargc, cargv) != -1)
rc = EXIT_SUCCESS;
goto end;
}
if (gotinputs) {
rc = EXIT_SUCCESS;
goto end;
}
/* Interactive session */
#ifdef HAVE_LIBREADLINE
rl_bind_key('?', cmd_help);
rl_bind_key('\t', cmd_complete);
#endif
const char *line;
do {
if ((line = readline(prompt()))) {
int n = parse_and_exec(conn, fmt, line);
(void)n;
#ifdef HAVE_READLINE_HISTORY
if (n != 0) add_history(line);
#endif
}
} while (!must_exit && line != NULL);
rc = EXIT_SUCCESS;
end:
while (!TAILQ_EMPTY(&inputs)) {
/* coverity[use_after_free]
TAILQ_REMOVE does the right thing */
struct input *first = TAILQ_FIRST(&inputs);
TAILQ_REMOVE(&inputs, first, next);
free(first->name);
free(first);
}
if (conn) lldpctl_release(conn);
if (root) commands_free(root);
return rc;
}
int log_register_commands(struct command_context *cmd_ctx)
{
return register_commands(cmd_ctx, NULL, log_command_handlers);
}
inline void
irccon::parse (const string & what)
{
//m_parser.enterMutex();
ircargs ia (htmlspecialchars(what));
/*
Insertme:
if (ia.command() == "NICK") {
yace->irc().insertUser(ia.arg(0), ia(arg4));
replace(yace->sql().getString("enters"),"%CNAME%",ia.arg(0));
return;
}
*/
if (ia.command () == "PRIVMSG")
{
commandargs ca(ia.rest());
if (ia.arg(0) == "YaCEServ") {
if (ia.prefix() == "NickServ") {
yace->sql().insertRegistry(ca.arg(0),ca.arg(1),ca.arg(2));
//m_parser.leaveMutex();
return;
}
// YaCEServ needs OperServ access for some Features
commandargs ca(ia.rest());
typedef hash_map<string, commandfunc> commandmap;
string command;
commandargs argz("");
commandfunc f;
commandmap cmds;
register_commands(cmds);
bool iscmd = false;
if (ca.arg(0) == "help") {
cout << "HELP REQUEST!" << endl;
iscmd = false;
yace->irc().send(":YaCEServ PRIVMSG " + ia.prefix() + ": YaCEServ Help:");
yace->irc().send(":YaCEServ PRIVMSG " + ia.prefix() + ": Pic <url>: Inserts picture");
yace->irc().send(":YaCEServ PRIVMSG " + ia.prefix() + ": YaCEServ Sound <url>: Inserts Sound");
yace->irc().send(":YaCEServ PRIVMSG " + ia.prefix() + ": YaCEServ Vipmsg <text>: Vipmsg with <text>");
yace->irc().send(":YaCEServ PRIVMSG " + ia.prefix() + ": YaCEServ Amsg <text>: Admin msg with <text>");
}
else if (ca.arg(0) == "Pic") {
iscmd = true;
command = "p";
argz = ca.rest(0);
}
if (iscmd) {
f = cmds[command];
f(ia.prefix(),argz);
}
}
user* u = yace->users().getUser(ia.prefix());
u->incrProp("said");
u->isetProp("silence",0);
if (ia.arg (0)[0] == '#')
{
if (ia.rest ()[0] == (char) 1)
{
string s_me = ia.rest ().substr (0, ia.rest ().length () - 2);
s_me = s_me.substr (s_me.find (" "), s_me.length () - s_me.find ("N"));
i2y_me (ia.prefix (), s_me, ia.arg(0));
//m_parser.leaveMutex();
return;
} else {
i2y_say (ia.prefix (), ia.rest (), ia.arg (0));
//m_parser.leaveMutex();
return;
}
} else {
i2y_whisper (ia.prefix (), ia.rest (), ia.arg (0));
//m_parser.leaveMutex();
return;
}
} else if (ia.command() == "PING")
{
string pong = "PONG " + name + " " + ia.arg (0);
yace->irc ().send (pong);
//m_parser.leaveMutex();
return;
}
else if (ia.command() == "TOPIC")
{
string msg = yace->sql().getString("settopic");
msg = replaceCommon(msg);
msg = replaceUser(ia.prefix(), msg);
msg = replace(msg, "%TEXT%", ia.rest().substr(0, ia.rest().length()-1));
sendRoomU(ia.prefix(),msg);
setTopic(getRoom(ia.arg(0)),ia.rest());
//m_parser.leaveMutex();
return;
}
else if (ia.command() == "NICK")
{
if (ia.prefix() != "") {
string tosend;
tosend = yace->sql().getString("nick");
tosend = replaceCommon(tosend);
tosend = replace(tosend, "%NICK%", ia.arg(0));
tosend = replaceUser(ia.prefix(), tosend);
yace->users().getUser(ia.prefix())->ssetProp("nick", ia.arg(0));
sendRoomU(ia.prefix(), tosend);
//m_parser.leaveMutex();
return;
}
string nick = ia.arg(0);
string host = ia.arg(4);
bool hasreg = false;
if (yace->users().existsUser(nick)) {
//m_parser.leaveMutex();
return;
}
hasreg = yace->sql().isReg(nick);
//if (hasreg) {
// We need NickServ-Plugins for identify
// yace->irc().send(":yace.filbboard.de KILL " + nick + " :Registered. If its your nick, please reconnect and identify");
//return;
//}
if(nick.length() >= 5) {
if (nick.substr(nick.length()-4,4) == "Serv" || nick == "DevNull" || nick == "Global" || nick == "BrotSheep") {
//m_parser.leaveMutex();
return;
}
}
user* irchehe = new user(ia.arg(0),ia.arg(4));
user* hehe = irchehe;
irchehe->IncRef();
yace->users().insertUser(irchehe);
yace->rooms().joinRoom(irchehe->getName(), "TEMP-ROOM"); // this is untill we got a JOIN
//TOLLE SACHEN
string regstrings = yace->sql().getConfStr("regstrings");
string regnums = yace->sql().getConfStr("regnums");
{
if(hasreg)
yace->sql().updateTime(hehe->getName());
commandargs str(regstrings);
string act;
string actval;
for(int i = 0; (act = str.arg(i)) != ""; ++i) {
unsigned long pos = act.find("=");
if(pos != string::npos) {
actval = act.substr(pos + 1);
act = act.substr(0, pos);
}
else {
actval = "";
}
if(hasreg)
hehe->ssetProp(act, yace->sql().getRegStr(nick, act));
else
hehe->ssetProp(act, actval);
}
commandargs num(regnums);
for(int i = 0; (act = num.arg(i)) != ""; ++i) {
unsigned long pos = act.find("=");
if(pos != string::npos) {
actval = act.substr(pos + 1);
act = act.substr(0, pos);
}
else {
actval = "";
}
long actnumval;
istringstream is(actval);
is >> actnumval;
if(hasreg)
hehe->isetProp(act, yace->sql().getRegNum(nick, act));
else
hehe->isetProp(act, actnumval);
}
}
// END TOLLE SACHEN
enters(irchehe);
yace->rooms().leaves(irchehe->getName(), true, "TEMP-ROOM");
irchehe->DecRef();
//m_parser.leaveMutex();
return;
}
else if (ia.command() == "JOIN") {
