int main(int argc, char *argv[])
{
pid_t child_pid;
int child_exit_status;
struct termios tty_attr;
struct winsize window_size;
int pty_master;
/* for select */
fd_set readfds;
fd_set writefds;
unsigned err_n_rpty = 0;
unsigned err_n_wpty = 0;
unsigned err_n_stdin = 0;
unsigned err_n_stdout = 0;
int done = 0;
/* the ring buffers */
char inbuf_mem[BUFSIZE];
char outbuf_mem[BUFSIZE];
struct ring_buffer inbuf;
struct ring_buffer outbuf;
rb_init(&inbuf, inbuf_mem, sizeof(inbuf_mem));
rb_init(&outbuf, outbuf_mem, sizeof(outbuf_mem));
if (argc == 1) {
printf("usage: %s PROGRAM [ARGS]...\n", argv[0]);
exit(1);
}
/* We need I/O calls to fail with EINTR on SIGCHLD... */
if (signal(SIGCHLD, sigchld_handler) == SIG_ERR) {
perror("signal(SIGCHLD,...)");
exit(EX_OSERR);
}
if (isatty(STDIN_FILENO)) {
/* get terminal parameters associated with stdout */
if (tcgetattr(STDOUT_FILENO, &tty_attr) < 0) {
perror("tcgetattr(stdout,...)");
exit(EX_OSERR);
}
/* get window size */
if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &window_size) < 0) {
perror("ioctl(stdout,...)");
exit(1);
}
child_pid = forkpty(&pty_master, NULL, &tty_attr, &window_size);
} else { /* not interactive */
child_pid = forkpty(&pty_master, NULL, NULL, NULL);
}
if (child_pid < 0) {
perror("forkpty()");
exit(EX_OSERR);
}
if (child_pid == 0) { /* in the child */
struct termios s_tty_attr;
if (tcgetattr(STDIN_FILENO, &s_tty_attr)) {
perror("tcgetattr(stdin,...)");
exit(EXIT_FAILURE);
}
/* Turn off echo */
s_tty_attr.c_lflag &= ~(ECHO | ECHOE | ECHOK | ECHONL);
/* Also turn of NL to CR?LF on output */
s_tty_attr.c_oflag &= ~(ONLCR);
if (tcsetattr(STDIN_FILENO, TCSANOW, &s_tty_attr)) {
perror("tcsetattr(stdin,...)");
exit(EXIT_FAILURE);
}
if (execvp(argv[1], argv + 1)) {
perror("execvp()");
exit(EXIT_FAILURE);
}
}
/* Non blocking mode for all file descriptors. */
setfd_nonblock(pty_master);
setfd_nonblock(STDIN_FILENO);
setfd_nonblock(STDOUT_FILENO);
if (isatty(STDIN_FILENO)) {
if (tty_semi_raw(STDIN_FILENO) < 0) {
perror("tty_semi_raw(stdin)");
}
if (atexit(tty_atexit) < 0) {
perror("atexit()");
}
}
do {
/* Accept events only on fds, that we can handle now. */
int do_select = 0;
FD_ZERO(&readfds);
FD_ZERO(&writefds);
if (rb_space(&outbuf) > 0 && err_n_rpty < MAXRETR) {
FD_SET(pty_master, &readfds);
do_select = 1;
}
if (!rb_isempty(&inbuf) && err_n_wpty < MAXRETR) {
FD_SET(pty_master, &writefds);
do_select = 1;
}
if (rb_space(&inbuf) > 0 && err_n_stdin < MAXRETR) {
FD_SET(STDIN_FILENO, &readfds);
do_select = 1;
}
if (!rb_isempty(&outbuf) && err_n_stdout < MAXRETR) {
FD_SET(STDOUT_FILENO, &writefds);
do_select = 1;
}
if (!do_select) {
#ifdef DEBUG
fprintf(stderr, "No I/O job for us, calling waitpid()...\n");
#endif
while (waitpid(child_pid, &child_exit_status, 0) < 0)
{
/* nothing */
}
break;
}
errno = 0;
int select_rc = select(pty_master + 1, &readfds, &writefds, NULL, NULL);
if (select_rc < 0 && errno != EINTR) {
perror("select()");
exit(EX_IOERR);
}
#ifdef DEBUG
fprintf(stderr, "select() returned %d\n", select_rc);
#endif
if (FD_ISSET(STDOUT_FILENO, &writefds)) {
#ifdef DEBUG
fprintf(stderr, "stdout can be written\n");
#endif
ssize_t n = rb_write(&outbuf, STDOUT_FILENO);
if (n <= 0 && n != EINTR && n != EAGAIN)
err_n_stdout++;
#ifdef DEBUG
if (n >= 0)
fprintf(stderr, "%d bytes written into stdout\n", n);
else
perror("write(stdout,...)");
#endif
}
if (FD_ISSET(pty_master, &writefds)) {
#ifdef DEBUG
fprintf(stderr, "pty_master can be written\n");
#endif
ssize_t n = rb_write(&inbuf, pty_master);
if (n <= 0 && n != EINTR && n != EAGAIN)
err_n_wpty++;
#ifdef DEBUG
if (n >= 0)
fprintf(stderr, "%d bytes written into pty_master\n", n);
else
perror("write(pty_master,...)");
#endif
}
if (FD_ISSET(STDIN_FILENO, &readfds)) {
#ifdef DEBUG
fprintf(stderr, "stdin can be read\n");
#endif
ssize_t n = rb_read(&inbuf, STDIN_FILENO);
if (n <= 0 && n != EINTR && n != EAGAIN)
err_n_stdin++;
#ifdef DEBUG
if (n >= 0)
fprintf(stderr, "%d bytes read from stdin\n", n);
else
perror("read(stdin,...)");
#endif
}
if (FD_ISSET(pty_master, &readfds)) {
#ifdef DEBUG
fprintf(stderr, "pty_master can be read\n");
#endif
ssize_t n = rb_read(&outbuf, pty_master);
if (n <= 0 && n != EINTR && n != EAGAIN)
err_n_rpty++;
#ifdef DEBUG
if (n >= 0)
fprintf(stderr, "%d bytes read from pty_master\n", n);
else
perror("read(pty_master,...)");
#endif
}
if (!done && waitpid(child_pid, &child_exit_status, WNOHANG) > 0)
done = 1;
} while (!done
|| !(rb_isempty(&inbuf) || err_n_wpty >= MAXRETR)
|| !(rb_isempty(&outbuf) || err_n_stdout >= MAXRETR));
#ifdef DEBUG
fprintf(stderr, "inbuf: %u bytes left, outbuf: %u bytes left\n", inbuf.count, outbuf.count);
fprintf(stderr, "err_n_rpty=%u, err_n_wpty=%u, err_n_stdin=%u, err_n_stdout=%u\n",
err_n_rpty, err_n_wpty, err_n_stdin, err_n_stdout);
#endif
if (WIFEXITED(child_exit_status))
exit(WEXITSTATUS(child_exit_status));
else if (WIFSIGNALED(child_exit_status))
exit(128 + WTERMSIG(child_exit_status));
exit(EXIT_FAILURE);
}
int cmd_clone(int argc, const char **argv, const char *prefix)
{
int is_bundle = 0, is_local;
struct stat buf;
const char *repo_name, *repo, *work_tree, *git_dir;
char *path, *dir;
int dest_exists;
const struct ref *refs, *remote_head;
const struct ref *remote_head_points_at;
const struct ref *our_head_points_at;
struct ref *mapped_refs;
struct strbuf key = STRBUF_INIT, value = STRBUF_INIT;
struct strbuf branch_top = STRBUF_INIT, reflog_msg = STRBUF_INIT;
struct transport *transport = NULL;
char *src_ref_prefix = "refs/heads/";
int err = 0;
struct refspec *refspec;
const char *fetch_pattern;
junk_pid = getpid();
packet_trace_identity("clone");
argc = parse_options(argc, argv, prefix, builtin_clone_options,
builtin_clone_usage, 0);
if (argc > 2)
usage_msg_opt(_("Too many arguments."),
builtin_clone_usage, builtin_clone_options);
if (argc == 0)
usage_msg_opt(_("You must specify a repository to clone."),
builtin_clone_usage, builtin_clone_options);
if (option_mirror)
option_bare = 1;
if (option_bare) {
if (option_origin)
die(_("--bare and --origin %s options are incompatible."),
option_origin);
option_no_checkout = 1;
}
if (!option_origin)
option_origin = "origin";
repo_name = argv[0];
path = get_repo_path(repo_name, &is_bundle);
if (path)
repo = xstrdup(absolute_path(repo_name));
else if (!strchr(repo_name, ':'))
die(_("repository '%s' does not exist"), repo_name);
else
repo = repo_name;
is_local = path && !is_bundle;
if (is_local && option_depth)
warning(_("--depth is ignored in local clones; use file:// instead."));
if (argc == 2)
dir = xstrdup(argv[1]);
else
dir = guess_dir_name(repo_name, is_bundle, option_bare);
strip_trailing_slashes(dir);
dest_exists = !stat(dir, &buf);
if (dest_exists && !is_empty_dir(dir))
die(_("destination path '%s' already exists and is not "
"an empty directory."), dir);
strbuf_addf(&reflog_msg, "clone: from %s", repo);
if (option_bare)
work_tree = NULL;
else {
work_tree = getenv("GIT_WORK_TREE");
if (work_tree && !stat(work_tree, &buf))
die(_("working tree '%s' already exists."), work_tree);
}
if (option_bare || work_tree)
git_dir = xstrdup(dir);
else {
work_tree = dir;
git_dir = xstrdup(mkpath("%s/.git", dir));
}
if (!option_bare) {
junk_work_tree = work_tree;
if (safe_create_leading_directories_const(work_tree) < 0)
die_errno(_("could not create leading directories of '%s'"),
work_tree);
if (!dest_exists && mkdir(work_tree, 0755))
die_errno(_("could not create work tree dir '%s'."),
work_tree);
set_git_work_tree(work_tree);
}
junk_git_dir = git_dir;
atexit(remove_junk);
sigchain_push_common(remove_junk_on_signal);
setenv(CONFIG_ENVIRONMENT, mkpath("%s/config", git_dir), 1);
if (safe_create_leading_directories_const(git_dir) < 0)
die(_("could not create leading directories of '%s'"), git_dir);
set_git_dir_init(git_dir, real_git_dir, 0);
if (real_git_dir)
git_dir = real_git_dir;
if (0 <= option_verbosity) {
if (option_bare)
printf(_("Cloning into bare repository %s...\n"), dir);
else
printf(_("Cloning into %s...\n"), dir);
}
init_db(option_template, INIT_DB_QUIET);
/*
* At this point, the config exists, so we do not need the
* environment variable. We actually need to unset it, too, to
* re-enable parsing of the global configs.
*/
unsetenv(CONFIG_ENVIRONMENT);
git_config(git_default_config, NULL);
if (option_bare) {
if (option_mirror)
src_ref_prefix = "refs/";
strbuf_addstr(&branch_top, src_ref_prefix);
git_config_set("core.bare", "true");
} else {
strbuf_addf(&branch_top, "refs/remotes/%s/", option_origin);
}
strbuf_addf(&value, "+%s*:%s*", src_ref_prefix, branch_top.buf);
if (option_mirror || !option_bare) {
/* Configure the remote */
strbuf_addf(&key, "remote.%s.fetch", option_origin);
git_config_set_multivar(key.buf, value.buf, "^$", 0);
strbuf_reset(&key);
if (option_mirror) {
strbuf_addf(&key, "remote.%s.mirror", option_origin);
git_config_set(key.buf, "true");
strbuf_reset(&key);
}
}
strbuf_addf(&key, "remote.%s.url", option_origin);
git_config_set(key.buf, repo);
strbuf_reset(&key);
if (option_reference)
setup_reference(git_dir);
fetch_pattern = value.buf;
refspec = parse_fetch_refspec(1, &fetch_pattern);
strbuf_reset(&value);
if (is_local) {
refs = clone_local(path, git_dir);
mapped_refs = wanted_peer_refs(refs, refspec);
} else {
struct remote *remote = remote_get(option_origin);
transport = transport_get(remote, remote->url[0]);
if (!transport->get_refs_list || !transport->fetch)
die(_("Don't know how to clone %s"), transport->url);
transport_set_option(transport, TRANS_OPT_KEEP, "yes");
if (option_depth)
transport_set_option(transport, TRANS_OPT_DEPTH,
option_depth);
transport_set_verbosity(transport, option_verbosity, option_progress);
if (option_upload_pack)
transport_set_option(transport, TRANS_OPT_UPLOADPACK,
option_upload_pack);
refs = transport_get_remote_refs(transport);
if (refs) {
mapped_refs = wanted_peer_refs(refs, refspec);
transport_fetch_refs(transport, mapped_refs);
}
}
if (refs) {
clear_extra_refs();
write_remote_refs(mapped_refs);
remote_head = find_ref_by_name(refs, "HEAD");
remote_head_points_at =
guess_remote_head(remote_head, mapped_refs, 0);
if (option_branch) {
struct strbuf head = STRBUF_INIT;
strbuf_addstr(&head, src_ref_prefix);
strbuf_addstr(&head, option_branch);
our_head_points_at =
find_ref_by_name(mapped_refs, head.buf);
strbuf_release(&head);
if (!our_head_points_at) {
warning(_("Remote branch %s not found in "
"upstream %s, using HEAD instead"),
option_branch, option_origin);
our_head_points_at = remote_head_points_at;
}
}
else
our_head_points_at = remote_head_points_at;
}
else {
warning(_("You appear to have cloned an empty repository."));
our_head_points_at = NULL;
remote_head_points_at = NULL;
remote_head = NULL;
option_no_checkout = 1;
if (!option_bare)
install_branch_config(0, "master", option_origin,
"refs/heads/master");
}
if (remote_head_points_at && !option_bare) {
struct strbuf head_ref = STRBUF_INIT;
strbuf_addstr(&head_ref, branch_top.buf);
strbuf_addstr(&head_ref, "HEAD");
create_symref(head_ref.buf,
remote_head_points_at->peer_ref->name,
reflog_msg.buf);
}
if (our_head_points_at) {
/* Local default branch link */
create_symref("HEAD", our_head_points_at->name, NULL);
if (!option_bare) {
const char *head = skip_prefix(our_head_points_at->name,
"refs/heads/");
update_ref(reflog_msg.buf, "HEAD",
our_head_points_at->old_sha1,
NULL, 0, DIE_ON_ERR);
install_branch_config(0, head, option_origin,
our_head_points_at->name);
}
} else if (remote_head) {
/* Source had detached HEAD pointing somewhere. */
if (!option_bare) {
update_ref(reflog_msg.buf, "HEAD",
remote_head->old_sha1,
NULL, REF_NODEREF, DIE_ON_ERR);
our_head_points_at = remote_head;
}
} else {
/* Nothing to checkout out */
if (!option_no_checkout)
warning(_("remote HEAD refers to nonexistent ref, "
"unable to checkout.\n"));
option_no_checkout = 1;
}
if (transport) {
transport_unlock_pack(transport);
transport_disconnect(transport);
}
if (!option_no_checkout) {
struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file));
struct unpack_trees_options opts;
struct tree *tree;
struct tree_desc t;
int fd;
/* We need to be in the new work tree for the checkout */
setup_work_tree();
fd = hold_locked_index(lock_file, 1);
memset(&opts, 0, sizeof opts);
opts.update = 1;
opts.merge = 1;
opts.fn = oneway_merge;
opts.verbose_update = (option_verbosity > 0);
opts.src_index = &the_index;
opts.dst_index = &the_index;
tree = parse_tree_indirect(our_head_points_at->old_sha1);
parse_tree(tree);
init_tree_desc(&t, tree->buffer, tree->size);
unpack_trees(1, &t, &opts);
if (write_cache(fd, active_cache, active_nr) ||
commit_locked_index(lock_file))
die(_("unable to write new index file"));
err |= run_hook(NULL, "post-checkout", sha1_to_hex(null_sha1),
sha1_to_hex(our_head_points_at->old_sha1), "1",
NULL);
if (!err && option_recursive)
err = run_command_v_opt(argv_submodule, RUN_GIT_CMD);
}
strbuf_release(&reflog_msg);
strbuf_release(&branch_top);
strbuf_release(&key);
strbuf_release(&value);
junk_pid = 0;
return err;
}
int main ( int argc, char **argv )
{
extern QueueObject_t *IndexQ;
struct sigaction sa;
sigset_t sigmsk;
uint32 count;
GlobalAbort = false;
/* Parse the command line options */
MainParseArgs( argc, argv );
mainThreadId = pthread_self();
/*
* Setup the sigmasks for this thread (which is the parent to all others).
* This will propogate to all children.
*/
sigfillset( &sigmsk );
sigdelset( &sigmsk, SIGUSR1 );
sigdelset( &sigmsk, SIGUSR2 );
sigdelset( &sigmsk, SIGINT );
sigdelset( &sigmsk, SIGSEGV );
sigdelset( &sigmsk, SIGILL );
sigdelset( &sigmsk, SIGFPE );
pthread_sigmask( SIG_SETMASK, &sigmsk, NULL );
/* Start up the Logging thread */
logging_initialize(FALSE);
thread_register( &mainThreadId, "thread_main", NULL );
/* Setup signal handler for SIGUSR1 (toggles Debug) */
sa.sa_sigaction = (sigAction_t)logging_toggle_debug;
sigemptyset( &sa.sa_mask );
sa.sa_flags = SA_RESTART;
sigaction( SIGUSR1, &sa, NULL );
/* Setup the exit handler */
atexit( MainDelayExit );
/* Setup signal handler for SIGINT (shut down cleanly) */
sa.sa_sigaction = signal_interrupt;
sigemptyset( &sa.sa_mask );
sa.sa_flags = SA_RESTART;
sigaction( SIGINT, &sa, NULL );
/* Setup signal handlers that are to be propogated to all threads */
sa.sa_sigaction = signal_everyone;
sigemptyset( &sa.sa_mask );
sa.sa_flags = SA_RESTART | SA_SIGINFO;
sigaction( SIGUSR2, &sa, NULL );
/* Setup signal handlers for SEGV, ILL, FPE */
sa.sa_sigaction = signal_death;
sigemptyset( &sa.sa_mask );
sa.sa_flags = SA_RESTART | SA_SIGINFO;
sigaction( SIGSEGV, &sa, NULL );
sigaction( SIGILL, &sa, NULL );
sigaction( SIGFPE, &sa, NULL );
/* Print the startup log messages */
LogBanner();
/* Setup the CLucene indexer */
clucene_init(1);
/* Setup the MySQL connection */
db_setup();
db_check_schema_main();
db_rebuild_clucene();
/* Wait for the clucene thread to finish emptying its queue */
while( (count = QueueUsed( IndexQ )) > 0 ) {
LogPrint( LOG_INFO, "%d left", count );
sleep( 1 );
}
GlobalAbort = TRUE;
return(0);
}
/*$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ main() $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$*/
int
main(int argc, char *argv[])
{
#ifdef _WITH_BURST_2
int cb2_ret;
#endif
int current_toggle,
exit_status = TRANSFER_SUCCESS,
j,
fd,
status,
loops,
rest,
blocksize,
*wmo_counter,
wmo_counter_fd = -1;
#ifdef WITH_ARCHIVE_COPY_INFO
unsigned int archived_copied = 0;
#endif
off_t no_of_bytes;
time_t connected,
#ifdef _WITH_BURST_2
diff_time,
#endif
end_transfer_time_file,
start_transfer_time_file = 0,
last_update_time,
now;
#ifdef _OUTPUT_LOG
clock_t end_time = 0,
start_time = 0;
struct tms tmsdummy;
#endif
char *p_file_name_buffer,
*buffer,
fullname[MAX_PATH_LENGTH + 1],
file_path[MAX_PATH_LENGTH];
clock_t clktck;
struct stat stat_buf;
struct job *p_db;
#ifdef SA_FULLDUMP
struct sigaction sact;
#endif
CHECK_FOR_VERSION(argc, argv);
#ifdef SA_FULLDUMP
/*
* When dumping core sure we do a FULL core dump!
*/
sact.sa_handler = SIG_DFL;
sact.sa_flags = SA_FULLDUMP;
sigemptyset(&sact.sa_mask);
if (sigaction(SIGSEGV, &sact, NULL) == -1)
{
system_log(ERROR_SIGN, __FILE__, __LINE__,
"sigaction() error : %s", strerror(errno));
exit(INCORRECT);
}
#endif
/* Do some cleanups when we exit. */
if (atexit(sf_wmo_exit) != 0)
{
system_log(ERROR_SIGN, __FILE__, __LINE__,
"Could not register exit function : %s", strerror(errno));
exit(INCORRECT);
}
/* Initialise variables. */
local_file_counter = 0;
files_to_send = init_sf(argc, argv, file_path, WMO_FLAG);
p_db = &db;
if ((clktck = sysconf(_SC_CLK_TCK)) <= 0)
{
system_log(ERROR_SIGN, __FILE__, __LINE__,
"Could not get clock ticks per second : %s",
strerror(errno));
exit(INCORRECT);
}
if (fsa->trl_per_process > 0)
{
if (fsa->trl_per_process < fsa->block_size)
{
blocksize = fsa->trl_per_process;
}
else
{
blocksize = fsa->block_size;
}
}
else
{
blocksize = fsa->block_size;
}
if ((signal(SIGINT, sig_kill) == SIG_ERR) ||
(signal(SIGQUIT, sig_exit) == SIG_ERR) ||
(signal(SIGTERM, SIG_IGN) == SIG_ERR) ||
(signal(SIGSEGV, sig_segv) == SIG_ERR) ||
(signal(SIGBUS, sig_bus) == SIG_ERR) ||
(signal(SIGHUP, SIG_IGN) == SIG_ERR) ||
(signal(SIGPIPE, SIG_IGN) == SIG_ERR))
{
system_log(ERROR_SIGN, __FILE__, __LINE__,
"signal() error : %s", strerror(errno));
exit(INCORRECT);
}
/* Now determine the real hostname. */
if (db.toggle_host == YES)
{
if (fsa->host_toggle == HOST_ONE)
{
(void)strcpy(db.hostname, fsa->real_hostname[HOST_TWO - 1]);
current_toggle = HOST_TWO;
}
else
{
(void)strcpy(db.hostname, fsa->real_hostname[HOST_ONE - 1]);
current_toggle = HOST_ONE;
}
}
else
{
(void)strcpy(db.hostname,
fsa->real_hostname[(int)(fsa->host_toggle - 1)]);
current_toggle = (int)fsa->host_toggle;
}
/* Connect to remote WMO-server. */
#ifdef FTP_CTRL_KEEP_ALIVE_INTERVAL
if (fsa->protocol_options & AFD_TCP_KEEPALIVE)
{
timeout_flag = transfer_timeout - 5;
if (timeout_flag < MIN_KEEP_ALIVE_INTERVAL)
{
timeout_flag = MIN_KEEP_ALIVE_INTERVAL;
}
}
#else
timeout_flag = OFF;
#endif
if ((status = wmo_connect(db.hostname, db.port, db.sndbuf_size)) != SUCCESS)
{
trans_log(ERROR_SIGN, __FILE__, __LINE__, NULL, NULL,
"WMO connection to <%s> at port %d failed (%d).",
db.hostname, db.port, status);
exit(eval_timeout(CONNECT_ERROR));
}
else
{
if (fsa->debug > NORMAL_MODE)
{
trans_db_log(INFO_SIGN, __FILE__, __LINE__, NULL,
"Connected to port %d.", db.port);
}
}
connected = time(NULL);
/* Inform FSA that we have finished connecting and */
/* will now start to transfer data. */
if (gsf_check_fsa(p_db) != NEITHER)
{
#ifdef LOCK_DEBUG
lock_region_w(fsa_fd, db.lock_offset + LOCK_CON, __FILE__, __LINE__);
#else
lock_region_w(fsa_fd, db.lock_offset + LOCK_CON);
#endif
fsa->job_status[(int)db.job_no].connect_status = WMO_ACTIVE;
fsa->job_status[(int)db.job_no].no_of_files = files_to_send;
fsa->connections += 1;
#ifdef LOCK_DEBUG
unlock_region(fsa_fd, db.lock_offset + LOCK_CON, __FILE__, __LINE__);
#else
unlock_region(fsa_fd, db.lock_offset + LOCK_CON);
#endif
}
/* Allocate buffer to read data from the source file. */
if ((buffer = malloc(blocksize + 1 + 4 /* For bulletin end. */)) == NULL)
{
system_log(ERROR_SIGN, __FILE__, __LINE__,
"malloc() error : %s", strerror(errno));
exit(ALLOC_ERROR);
}
if (db.special_flag & WITH_SEQUENCE_NUMBER)
{
char counter_file_name[MAX_FILENAME_LENGTH];
(void)snprintf(counter_file_name, MAX_FILENAME_LENGTH, "/%s.%d", db.host_alias, db.port);
if ((wmo_counter_fd = open_counter_file(counter_file_name, &wmo_counter)) < 0)
{
system_log(ERROR_SIGN, __FILE__, __LINE__,
"Failed to open counter file `%s'.", counter_file_name);
}
}
#ifdef _WITH_BURST_2
do
{
if (burst_2_counter > 0)
{
if (fsa->debug > NORMAL_MODE)
{
trans_db_log(INFO_SIGN, __FILE__, __LINE__, NULL, "WMO Bursting.");
}
}
#endif
/* Send all files. */
p_file_name_buffer = file_name_buffer;
p_file_size_buffer = file_size_buffer;
last_update_time = time(NULL);
local_file_size = 0;
for (files_send = 0; files_send < files_to_send; files_send++)
{
(void)snprintf(fullname, MAX_PATH_LENGTH + 1, "%s/%s",
file_path, p_file_name_buffer);
if (*p_file_size_buffer > 0)
{
int end_length = 0,
header_length = 0,
length_type_indicator = 10;
if (gsf_check_fsa(p_db) != NEITHER)
{
fsa->job_status[(int)db.job_no].file_size_in_use = *p_file_size_buffer;
(void)strcpy(fsa->job_status[(int)db.job_no].file_name_in_use,
p_file_name_buffer);
}
/* Open local file. */
#ifdef O_LARGEFILE
if ((fd = open(fullname, O_RDONLY | O_LARGEFILE)) == -1)
#else
if ((fd = open(fullname, O_RDONLY)) == -1)
#endif
{
trans_log(ERROR_SIGN, __FILE__, __LINE__, NULL, NULL,
"Failed to open local file `%s' : %s",
fullname, strerror(errno));
wmo_quit();
exit(OPEN_LOCAL_ERROR);
}
if (fsa->debug > NORMAL_MODE)
{
trans_db_log(INFO_SIGN, __FILE__, __LINE__, NULL,
"Open local file `%s'", fullname);
}
#ifdef _OUTPUT_LOG
if (db.output_log == YES)
{
start_time = times(&tmsdummy);
}
#endif
/*
* When the contents does not contain a bulletin header
* it must be stored in the file name.
*/
if (db.special_flag & FILE_NAME_IS_HEADER)
{
int space_count;
char *ptr = p_file_name_buffer;
buffer[length_type_indicator] = 1; /* SOH */
buffer[length_type_indicator + 1] = '\015'; /* CR */
buffer[length_type_indicator + 2] = '\015'; /* CR */
buffer[length_type_indicator + 3] = '\012'; /* LF */
header_length = 4;
space_count = 0;
if (wmo_counter_fd > 0)
{
if (next_counter(wmo_counter_fd, wmo_counter,
MAX_WMO_COUNTER) < 0)
{
close_counter_file(wmo_counter_fd, &wmo_counter);
wmo_counter_fd = -1;
wmo_counter = NULL;
system_log(ERROR_SIGN, __FILE__, __LINE__,
"Failed to get next WMO counter.");
}
else
{
if (*wmo_counter < 10)
{
buffer[length_type_indicator + header_length] = '0';
buffer[length_type_indicator + header_length + 1] = '0';
buffer[length_type_indicator + header_length + 2] = *wmo_counter + '0';
}
else if (*wmo_counter < 100)
{
buffer[length_type_indicator + header_length] = '0';
buffer[length_type_indicator + header_length + 1] = (*wmo_counter / 10) + '0';
buffer[length_type_indicator + header_length + 2] = (*wmo_counter % 10) + '0';
}
else if (*wmo_counter < 1000)
{
buffer[length_type_indicator + header_length] = ((*wmo_counter / 100) % 10) + '0';
buffer[length_type_indicator + header_length + 1] = ((*wmo_counter / 10) % 10) + '0';
buffer[length_type_indicator + header_length + 2] = (*wmo_counter % 10) + '0';
}
buffer[length_type_indicator + header_length + 3] = '\015'; /* CR */
buffer[length_type_indicator + header_length + 4] = '\015'; /* CR */
buffer[length_type_indicator + header_length + 5] = '\012'; /* LF */
header_length += 6;
}
} /* if (wmo_counter_fd > 0) */
for (;;)
{
while ((*ptr != '_') && (*ptr != '-') && (*ptr != ' ') &&
(*ptr != '\0') && (*ptr != '.') && (*ptr != ';'))
{
buffer[length_type_indicator + header_length] = *ptr;
header_length++; ptr++;
}
if ((*ptr == '\0') || (*ptr == '.') || (*ptr == ';'))
{
break;
}
else
{
if (space_count == 2)
{
if ((isalpha((int)(*(ptr + 1)))) &&
(isalpha((int)(*(ptr + 2)))) &&
(isalpha((int)(*(ptr + 3)))))
{
buffer[length_type_indicator + header_length] = ' ';
buffer[length_type_indicator + header_length + 1] = *(ptr + 1);
buffer[length_type_indicator + header_length + 2] = *(ptr + 2);
buffer[length_type_indicator + header_length + 3] = *(ptr + 3);
header_length += 4;
}
break;
}
else
{
buffer[length_type_indicator + header_length] = ' ';
header_length++; ptr++; space_count++;
}
}
} /* for (;;) */
buffer[length_type_indicator + header_length] = '\015'; /* CR */
buffer[length_type_indicator + header_length + 1] = '\015'; /* CR */
buffer[length_type_indicator + header_length + 2] = '\012'; /* LF */
header_length += 3;
end_length = 4;
}
/* Read (local) and write (remote) file. */
no_of_bytes = 0;
loops = (length_type_indicator + header_length + *p_file_size_buffer) / blocksize;
rest = (length_type_indicator + header_length + *p_file_size_buffer) % blocksize;
if ((db.special_flag & FILE_NAME_IS_HEADER) && (rest == 0))
{
loops--;
rest = blocksize;
}
/* Write length and type indicator. */
(void)snprintf(buffer, 9, "%08lu",
(unsigned long)(*p_file_size_buffer + header_length + end_length));
if (db.transfer_mode == 'I')
{
buffer[length_type_indicator - 2] = 'B';
buffer[length_type_indicator - 1] = 'I';
}
else if (db.transfer_mode == 'A')
{
buffer[length_type_indicator - 2] = 'A';
buffer[length_type_indicator - 1] = 'N';
}
else
{
buffer[length_type_indicator - 2] = 'F';
buffer[length_type_indicator - 1] = 'X';
}
if (fsa->trl_per_process > 0)
{
init_limit_transfer_rate();
}
if (fsa->protocol_options & TIMEOUT_TRANSFER)
{
start_transfer_time_file = time(NULL);
}
for (;;)
{
for (j = 0; j < loops; j++)
{
#ifdef _SIMULATE_SLOW_TRANSFER
(void)sleep(_SIMULATE_SLOW_TRANSFER);
#endif
if ((status = read(fd,
(buffer + length_type_indicator + header_length),
(blocksize - length_type_indicator - header_length))) != (blocksize - length_type_indicator - header_length))
{
trans_log(ERROR_SIGN, __FILE__, __LINE__, NULL, NULL,
"Could not read() local file `%s' : %s",
fullname, strerror(errno));
wmo_quit();
exit(READ_LOCAL_ERROR);
}
if ((status = wmo_write(buffer, blocksize)) != SUCCESS)
{
trans_log(ERROR_SIGN, __FILE__, __LINE__, NULL, NULL,
"Failed to write block from file `%s' to remote port %d [%d].",
p_file_name_buffer, db.port, status);
wmo_quit();
exit(eval_timeout(WRITE_REMOTE_ERROR));
}
if (fsa->trl_per_process > 0)
{
limit_transfer_rate(blocksize, fsa->trl_per_process,
clktck);
}
no_of_bytes += blocksize;
if (gsf_check_fsa(p_db) != NEITHER)
{
fsa->job_status[(int)db.job_no].file_size_in_use_done = no_of_bytes;
fsa->job_status[(int)db.job_no].file_size_done += blocksize;
fsa->job_status[(int)db.job_no].bytes_send += blocksize;
if (fsa->protocol_options & TIMEOUT_TRANSFER)
{
end_transfer_time_file = time(NULL);
if (end_transfer_time_file < start_transfer_time_file)
{
start_transfer_time_file = end_transfer_time_file;
}
else
{
if ((end_transfer_time_file - start_transfer_time_file) > transfer_timeout)
{
trans_log(INFO_SIGN, __FILE__, __LINE__, NULL, NULL,
#if SIZEOF_TIME_T == 4
"Transfer timeout reached for `%s' after %ld seconds.",
#else
"Transfer timeout reached for `%s' after %lld seconds.",
#endif
fsa->job_status[(int)db.job_no].file_name_in_use,
(pri_time_t)(end_transfer_time_file - start_transfer_time_file));
wmo_quit();
exitflag = 0;
exit(STILL_FILES_TO_SEND);
}
}
}
}
if (length_type_indicator > 0)
{
length_type_indicator = 0;
header_length = 0;
}
} /* for (j = 0; j < loops; j++) */
if (rest > 0)
{
if ((status = read(fd,
(buffer + length_type_indicator + header_length),
(rest - length_type_indicator - header_length))) != (rest - length_type_indicator - header_length))
{
trans_log(ERROR_SIGN, __FILE__, __LINE__, NULL, NULL,
"Could not read() local file `%s' : %s",
fullname, strerror(errno));
wmo_quit();
exit(READ_LOCAL_ERROR);
}
if (end_length == 4)
{
buffer[rest] = '\015';
buffer[rest + 1] = '\015';
buffer[rest + 2] = '\012';
buffer[rest + 3] = 3; /* ETX */
}
if ((status = wmo_write(buffer, rest + end_length)) != SUCCESS)
{
trans_log(ERROR_SIGN, __FILE__, __LINE__, NULL, NULL,
"Failed to write rest of file to remote port %d [%d].",
p_file_name_buffer, db.port, status);
wmo_quit();
exit(eval_timeout(WRITE_REMOTE_ERROR));
}
if (fsa->trl_per_process > 0)
{
limit_transfer_rate(rest + end_length,
fsa->trl_per_process, clktck);
}
no_of_bytes += rest + end_length;
if (gsf_check_fsa(p_db) != NEITHER)
{
fsa->job_status[(int)db.job_no].file_size_in_use_done = no_of_bytes;
fsa->job_status[(int)db.job_no].file_size_done += rest;
fsa->job_status[(int)db.job_no].bytes_send += rest;
}
}
/*
* Since there are always some users sending files to the
* AFD not in dot notation, lets check here if this is really
* the EOF.
* If not lets continue so long until we hopefully have reached
* the EOF.
* NOTE: This is NOT a fool proof way. There must be a better
* way!
*/
if (fstat(fd, &stat_buf) == -1)
{
(void)rec(transfer_log_fd, DEBUG_SIGN,
"Hmmm. Failed to stat() `%s' : %s (%s %d)\n",
fullname, strerror(errno), __FILE__, __LINE__);
break;
}
else
{
if (stat_buf.st_size > *p_file_size_buffer)
{
char sign[LOG_SIGN_LENGTH];
if (db.special_flag & SILENT_NOT_LOCKED_FILE)
{
(void)memcpy(sign, DEBUG_SIGN, LOG_SIGN_LENGTH);
}
else
{
(void)memcpy(sign, WARN_SIGN, LOG_SIGN_LENGTH);
}
loops = (stat_buf.st_size - *p_file_size_buffer) / blocksize;
rest = (stat_buf.st_size - *p_file_size_buffer) % blocksize;
*p_file_size_buffer = stat_buf.st_size;
/*
* Give a warning in the receive log, so some action
* can be taken against the originator.
*/
receive_log(sign, __FILE__, __LINE__, 0L, db.id.job,
"File `%s' for host %s was DEFINITELY send without any locking. #%x",
p_file_name_buffer, fsa->host_dsp_name, db.id.job);
}
else
{
break;
}
}
} /* for (;;) */
if (db.special_flag & WMO_CHECK_ACKNOWLEDGE)
{
int ret;
if ((ret = wmo_check_reply()) == INCORRECT)
{
trans_log(ERROR_SIGN, __FILE__, __LINE__, NULL, NULL,
"Failed to receive reply from port %d for file %s.",
db.port, p_file_name_buffer);
wmo_quit();
exit(eval_timeout(CHECK_REPLY_ERROR));
}
else if (ret == NEGATIV_ACKNOWLEDGE)
{
trans_log(ERROR_SIGN, __FILE__, __LINE__, NULL, NULL,
"Received negative acknowledge from remote port %d for file %s.",
db.port, p_file_name_buffer);
}
}
#ifdef _OUTPUT_LOG
if (db.output_log == YES)
{
end_time = times(&tmsdummy);
}
#endif
/* Close local file. */
if (close(fd) == -1)
{
(void)rec(transfer_log_fd, WARN_SIGN,
"%-*s[%d]: Failed to close() local file %s : %s (%s %d)\n",
MAX_HOSTNAME_LENGTH, tr_hostname, (int)db.job_no,
p_file_name_buffer, strerror(errno),
__FILE__, __LINE__);
/*
* Since we usually do not send more then 100 files and
* sf_wmo() will exit(), there is no point in stopping
* the transmission.
*/
}
}
else
{
trans_log(INFO_SIGN, __FILE__, __LINE__, NULL, NULL,
"File `%s' is of zero length, ignoring.",
p_file_name_buffer);
}
/* Update FSA, one file transmitted. */
if (gsf_check_fsa(p_db) != NEITHER)
{
fsa->job_status[(int)db.job_no].file_name_in_use[0] = '\0';
fsa->job_status[(int)db.job_no].no_of_files_done++;
fsa->job_status[(int)db.job_no].file_size_in_use = 0;
fsa->job_status[(int)db.job_no].file_size_in_use_done = 0;
local_file_size += *p_file_size_buffer;
local_file_counter += 1;
now = time(NULL);
if (now >= (last_update_time + LOCK_INTERVAL_TIME))
{
last_update_time = now;
update_tfc(local_file_counter, local_file_size,
p_file_size_buffer, files_to_send,
files_send, now);
local_file_size = 0;
local_file_counter = 0;
}
}
#ifdef _WITH_TRANS_EXEC
if (db.special_flag & TRANS_EXEC)
{
trans_exec(file_path, fullname, p_file_name_buffer, clktck);
}
#endif
#ifdef _OUTPUT_LOG
if (db.output_log == YES)
{
if (ol_fd == -2)
{
# ifdef WITHOUT_FIFO_RW_SUPPORT
output_log_fd(&ol_fd, &ol_readfd, &db.output_log);
# else
output_log_fd(&ol_fd, &db.output_log);
# endif
}
if ((ol_fd > -1) && (ol_data == NULL))
{
output_log_ptrs(&ol_retries,
&ol_job_number,
&ol_data, /* Pointer to buffer. */
&ol_file_name,
&ol_file_name_length,
&ol_archive_name_length,
&ol_file_size,
&ol_unl,
&ol_size,
&ol_transfer_time,
&ol_output_type,
db.host_alias,
(current_toggle - 1),
WMO,
&db.output_log);
}
}
#endif
/* Now archive file if necessary. */
if ((db.archive_time > 0) &&
(p_db->archive_dir[0] != FAILED_TO_CREATE_ARCHIVE_DIR))
{
#ifdef WITH_ARCHIVE_COPY_INFO
int ret;
#endif
/*
* By telling the function archive_file() that this
* is the first time to archive a file for this job
* (in struct p_db) it does not always have to check
* whether the directory has been created or not. And
* we ensure that we do not create duplicate names
* when adding db.archive_time to msg_name.
*/
#ifdef WITH_ARCHIVE_COPY_INFO
if ((ret = archive_file(file_path, p_file_name_buffer, p_db)) < 0)
#else
if (archive_file(file_path, p_file_name_buffer, p_db) < 0)
#endif
{
if (fsa->debug > NORMAL_MODE)
{
trans_db_log(ERROR_SIGN, __FILE__, __LINE__, NULL,
"Failed to archive file `%s'",
p_file_name_buffer);
}
/*
* NOTE: We _MUST_ delete the file we just send,
* else the file directory will run full!
*/
if (unlink(fullname) == -1)
{
system_log(ERROR_SIGN, __FILE__, __LINE__,
"Could not unlink() local file `%s' after sending it successfully : %s",
fullname, strerror(errno));
}
#ifdef _OUTPUT_LOG
if (db.output_log == YES)
{
(void)memcpy(ol_file_name, db.p_unique_name, db.unl);
(void)strcpy(ol_file_name + db.unl, p_file_name_buffer);
*ol_file_name_length = (unsigned short)strlen(ol_file_name);
ol_file_name[*ol_file_name_length] = SEPARATOR_CHAR;
ol_file_name[*ol_file_name_length + 1] = '\0';
(*ol_file_name_length)++;
*ol_file_size = *p_file_size_buffer;
*ol_job_number = fsa->job_status[(int)db.job_no].job_id;
*ol_retries = db.retries;
*ol_unl = db.unl;
*ol_transfer_time = end_time - start_time;
*ol_archive_name_length = 0;
*ol_output_type = OT_NORMAL_DELIVERED + '0';
ol_real_size = *ol_file_name_length + ol_size;
if (write(ol_fd, ol_data, ol_real_size) != ol_real_size)
{
system_log(ERROR_SIGN, __FILE__, __LINE__,
"write() error : %s", strerror(errno));
}
}
#endif
}
else
{
if (fsa->debug > NORMAL_MODE)
{
trans_db_log(INFO_SIGN, __FILE__, __LINE__, NULL,
"Archived file `%s'", p_file_name_buffer);
}
#ifdef WITH_ARCHIVE_COPY_INFO
if (ret == DATA_COPIED)
{
archived_copied++;
}
#endif
#ifdef _OUTPUT_LOG
if (db.output_log == YES)
{
(void)memcpy(ol_file_name, db.p_unique_name, db.unl);
(void)strcpy(ol_file_name + db.unl, p_file_name_buffer);
*ol_file_name_length = (unsigned short)strlen(ol_file_name);
ol_file_name[*ol_file_name_length] = SEPARATOR_CHAR;
ol_file_name[*ol_file_name_length + 1] = '\0';
(*ol_file_name_length)++;
(void)strcpy(&ol_file_name[*ol_file_name_length + 1],
&db.archive_dir[db.archive_offset]);
*ol_file_size = *p_file_size_buffer;
*ol_job_number = fsa->job_status[(int)db.job_no].job_id;
*ol_retries = db.retries;
*ol_unl = db.unl;
*ol_transfer_time = end_time - start_time;
*ol_archive_name_length = (unsigned short)strlen(&ol_file_name[*ol_file_name_length + 1]);
*ol_output_type = OT_NORMAL_DELIVERED + '0';
ol_real_size = *ol_file_name_length +
*ol_archive_name_length + 1 + ol_size;
if (write(ol_fd, ol_data, ol_real_size) != ol_real_size)
{
system_log(ERROR_SIGN, __FILE__, __LINE__,
"write() error : %s", strerror(errno));
}
}
#endif
}
}
else
{
#ifdef WITH_UNLINK_DELAY
int unlink_loops = 0;
try_again_unlink:
#endif
/* Delete the file we just have send. */
if (unlink(fullname) == -1)
{
#ifdef WITH_UNLINK_DELAY
if ((errno == EBUSY) && (unlink_loops < 20))
{
(void)my_usleep(100000L);
unlink_loops++;
goto try_again_unlink;
}
#endif
system_log(ERROR_SIGN, __FILE__, __LINE__,
"Could not unlink() local file %s after sending it successfully : %s",
fullname, strerror(errno));
}
#ifdef _OUTPUT_LOG
if (db.output_log == YES)
{
(void)memcpy(ol_file_name, db.p_unique_name, db.unl);
(void)strcpy(ol_file_name + db.unl, p_file_name_buffer);
*ol_file_name_length = (unsigned short)strlen(ol_file_name);
ol_file_name[*ol_file_name_length] = SEPARATOR_CHAR;
ol_file_name[*ol_file_name_length + 1] = '\0';
(*ol_file_name_length)++;
*ol_file_size = *p_file_size_buffer;
*ol_job_number = fsa->job_status[(int)db.job_no].job_id;
*ol_retries = db.retries;
*ol_unl = db.unl;
*ol_transfer_time = end_time - start_time;
*ol_archive_name_length = 0;
*ol_output_type = OT_NORMAL_DELIVERED + '0';
ol_real_size = *ol_file_name_length + ol_size;
if (write(ol_fd, ol_data, ol_real_size) != ol_real_size)
{
system_log(ERROR_SIGN, __FILE__, __LINE__,
"write() error : %s", strerror(errno));
}
}
#endif
}
/*
* After each successful transfer set error
* counter to zero, so that other jobs can be
* started.
*/
if (gsf_check_fsa(p_db) != NEITHER)
{
if ((*p_file_size_buffer > 0) && (fsa->error_counter > 0))
{
int fd,
#ifdef WITHOUT_FIFO_RW_SUPPORT
readfd,
#endif
j;
char fd_wake_up_fifo[MAX_PATH_LENGTH];
#ifdef LOCK_DEBUG
lock_region_w(fsa_fd, db.lock_offset + LOCK_EC, __FILE__, __LINE__);
#else
lock_region_w(fsa_fd, db.lock_offset + LOCK_EC);
#endif
fsa->error_counter = 0;
/*
* Wake up FD!
*/
(void)snprintf(fd_wake_up_fifo, MAX_PATH_LENGTH, "%s%s%s",
p_work_dir, FIFO_DIR, FD_WAKE_UP_FIFO);
#ifdef WITHOUT_FIFO_RW_SUPPORT
if (open_fifo_rw(fd_wake_up_fifo, &readfd, &fd) == -1)
#else
if ((fd = open(fd_wake_up_fifo, O_RDWR)) == -1)
#endif
{
system_log(WARN_SIGN, __FILE__, __LINE__,
"Failed to open() FIFO %s : %s",
fd_wake_up_fifo, strerror(errno));
}
else
{
if (write(fd, "", 1) != 1)
{
system_log(WARN_SIGN, __FILE__, __LINE__,
"Failed to write() to FIFO %s : %s",
fd_wake_up_fifo, strerror(errno));
}
#ifdef WITHOUT_FIFO_RW_SUPPORT
if (close(readfd) == -1)
{
system_log(DEBUG_SIGN, __FILE__, __LINE__,
"Failed to close() FIFO %s (read) : %s",
fd_wake_up_fifo, strerror(errno));
}
#endif
if (close(fd) == -1)
{
system_log(DEBUG_SIGN, __FILE__, __LINE__,
"Failed to close() FIFO %s : %s",
fd_wake_up_fifo, strerror(errno));
}
}
/*
* Remove the error condition (NOT_WORKING) from all jobs
* of this host.
*/
for (j = 0; j < fsa->allowed_transfers; j++)
{
if ((j != db.job_no) &&
(fsa->job_status[j].connect_status == NOT_WORKING))
{
fsa->job_status[j].connect_status = DISCONNECT;
}
}
fsa->error_history[0] = 0;
fsa->error_history[1] = 0;
#ifdef LOCK_DEBUG
unlock_region(fsa_fd, db.lock_offset + LOCK_EC, __FILE__, __LINE__);
#else
unlock_region(fsa_fd, db.lock_offset + LOCK_EC);
#endif
#ifdef LOCK_DEBUG
lock_region_w(fsa_fd, db.lock_offset + LOCK_HS, __FILE__, __LINE__);
#else
lock_region_w(fsa_fd, db.lock_offset + LOCK_HS);
#endif
now = time(NULL);
if (now > fsa->end_event_handle)
{
fsa->host_status &= ~(EVENT_STATUS_FLAGS | AUTO_PAUSE_QUEUE_STAT);
if (fsa->end_event_handle > 0L)
{
fsa->end_event_handle = 0L;
}
if (fsa->start_event_handle > 0L)
{
fsa->start_event_handle = 0L;
}
}
else
{
fsa->host_status &= ~(EVENT_STATUS_STATIC_FLAGS | AUTO_PAUSE_QUEUE_STAT);
}
#ifdef LOCK_DEBUG
unlock_region(fsa_fd, db.lock_offset + LOCK_HS, __FILE__, __LINE__);
#else
unlock_region(fsa_fd, db.lock_offset + LOCK_HS);
#endif
/*
* Since we have successfully transmitted a file, no need to
* have the queue stopped anymore.
*/
if (fsa->host_status & AUTO_PAUSE_QUEUE_STAT)
{
char sign[LOG_SIGN_LENGTH];
error_action(fsa->host_alias, "stop", HOST_ERROR_ACTION);
event_log(0L, EC_HOST, ET_EXT, EA_ERROR_END, "%s",
fsa->host_alias);
if ((fsa->host_status & HOST_ERROR_OFFLINE_STATIC) ||
(fsa->host_status & HOST_ERROR_OFFLINE) ||
(fsa->host_status & HOST_ERROR_OFFLINE_T))
{
(void)memcpy(sign, OFFLINE_SIGN, LOG_SIGN_LENGTH);
}
else
{
(void)memcpy(sign, INFO_SIGN, LOG_SIGN_LENGTH);
}
trans_log(sign, __FILE__, __LINE__, NULL, NULL,
"Starting input queue that was stopped by init_afd.");
event_log(0L, EC_HOST, ET_AUTO, EA_START_QUEUE, "%s",
fsa->host_alias);
}
} /* if (fsa->error_counter > 0) */
#ifdef WITH_ERROR_QUEUE
if (fsa->host_status & ERROR_QUEUE_SET)
{
remove_from_error_queue(db.id.job, fsa, db.fsa_pos, fsa_fd);
}
#endif
if (fsa->host_status & HOST_ACTION_SUCCESS)
{
error_action(fsa->host_alias, "start", HOST_SUCCESS_ACTION);
}
}
p_file_name_buffer += MAX_FILENAME_LENGTH;
p_file_size_buffer++;
} /* for (files_send = 0; files_send < files_to_send; files_send++) */
#ifdef WITH_ARCHIVE_COPY_INFO
if (archived_copied > 0)
{
trans_log(DEBUG_SIGN, __FILE__, __LINE__, NULL, NULL,
"Copied %u files to archive.", archived_copied);
archived_copied = 0;
}
#endif
if (local_file_counter)
{
if (gsf_check_fsa(p_db) != NEITHER)
{
update_tfc(local_file_counter, local_file_size,
p_file_size_buffer, files_to_send, files_send,
time(NULL));
local_file_size = 0;
local_file_counter = 0;
}
}
/*
* Remove file directory, but only when all files have
* been transmitted.
*/
if ((files_to_send == files_send) || (files_to_send < 1))
{
if (rmdir(file_path) < 0)
{
system_log(ERROR_SIGN, __FILE__, __LINE__,
"Failed to remove directory %s : %s",
file_path, strerror(errno));
}
}
else
{
system_log(WARN_SIGN, __FILE__, __LINE__,
"There are still %d files for %s. Will NOT remove this job!",
files_to_send - files_send, file_path);
exit_status = STILL_FILES_TO_SEND;
}
#ifdef _WITH_BURST_2
burst_2_counter++;
diff_time = time(NULL) - connected;
if (((fsa->protocol_options & KEEP_CONNECTED_DISCONNECT) &&
(db.keep_connected > 0) && (diff_time > db.keep_connected)) ||
((db.disconnect > 0) && (diff_time > db.disconnect)))
{
cb2_ret = NO;
break;
}
} while ((cb2_ret = check_burst_sf(file_path, &files_to_send, 0,
# ifdef _WITH_INTERRUPT_JOB
0,
# endif
# ifdef _OUTPUT_LOG
&ol_fd,
# endif
# ifndef AFDBENCH_CONFIG
NULL,
# endif
NULL)) == YES);
burst_2_counter--;
if (cb2_ret == NEITHER)
{
exit_status = STILL_FILES_TO_SEND;
}
#endif /* _WITH_BURST_2 */
free(buffer);
/* Disconnect from remote port. */
wmo_quit();
if ((fsa != NULL) && (fsa->debug > NORMAL_MODE))
{
trans_db_log(INFO_SIGN, __FILE__, __LINE__, NULL,
"Disconnected from port %d.", db.port);
}
if (wmo_counter_fd > 0)
{
close_counter_file(wmo_counter_fd, &wmo_counter);
}
exitflag = 0;
exit(exit_status);
}
int main(int argc, char **argv)
{
// init global vars
initSharedMem();
// register exit callback
atexit(exitCB);
// init GLUT and GL
initGLUT(argc, argv);
initGL();
// create a texture object
glGenTextures(1, &textureId);
glBindTexture(GL_TEXTURE_2D, textureId);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE); // automatic mipmap generation included in OpenGL v1.4
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, TEXTURE_WIDTH, TEXTURE_HEIGHT, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glBindTexture(GL_TEXTURE_2D, 0);
// get OpenGL info
glInfo glInfo;
glInfo.getInfo();
//glInfo.printSelf();
#ifdef _WIN32
// check if FBO is supported by your video card
if(glInfo.isExtensionSupported("GL_ARB_framebuffer_object"))
{
// get pointers to GL functions
glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)wglGetProcAddress("glGenFramebuffers");
glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)wglGetProcAddress("glDeleteFramebuffers");
glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)wglGetProcAddress("glBindFramebuffer");
glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)wglGetProcAddress("glCheckFramebufferStatus");
glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)wglGetProcAddress("glGetFramebufferAttachmentParameteriv");
glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)wglGetProcAddress("glGenerateMipmap");
glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)wglGetProcAddress("glFramebufferTexture1D");
glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)wglGetProcAddress("glFramebufferTexture2D");
glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)wglGetProcAddress("glFramebufferTexture3D");
glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)wglGetProcAddress("glFramebufferTextureLayer");
glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)wglGetProcAddress("glFramebufferRenderbuffer");
glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)wglGetProcAddress("glIsFramebuffer");
glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)wglGetProcAddress("glBlitFramebuffer");
glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)wglGetProcAddress("glGenRenderbuffers");
glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)wglGetProcAddress("glDeleteRenderbuffers");
glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)wglGetProcAddress("glBindRenderbuffer");
glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)wglGetProcAddress("glRenderbufferStorage");
glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)wglGetProcAddress("glRenderbufferStorageMultisample");
glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)wglGetProcAddress("glGetRenderbufferParameteriv");
glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)wglGetProcAddress("glIsRenderbuffer");
// check once again FBO extension
if(glGenFramebuffers && glDeleteFramebuffers && glBindFramebuffer && glCheckFramebufferStatus &&
glGetFramebufferAttachmentParameteriv && glGenerateMipmap && glFramebufferTexture1D && glFramebufferTexture2D && glFramebufferTexture3D &&
glFramebufferTextureLayer && glFramebufferRenderbuffer && glIsFramebuffer && glBlitFramebuffer &&
glGenRenderbuffers && glDeleteRenderbuffers && glBindRenderbuffer && glRenderbufferStorage &&
glRenderbufferStorageMultisample && glGetRenderbufferParameteriv && glIsRenderbuffer)
{
fboSupported = fboUsed = true;
std::cout << "Video card supports GL_ARB_framebuffer_object." << std::endl;
}
else
{
fboSupported = fboUsed = false;
std::cout << "Video card does NOT support GL_ARB_framebuffer_object." << std::endl;
}
}
// check EXT_swap_control is supported
if(glInfo.isExtensionSupported("WGL_EXT_swap_control"))
{
// get pointers to WGL functions
wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)wglGetProcAddress("wglSwapIntervalEXT");
wglGetSwapIntervalEXT = (PFNWGLGETSWAPINTERVALEXTPROC)wglGetProcAddress("wglGetSwapIntervalEXT");
if(wglSwapIntervalEXT && wglGetSwapIntervalEXT)
{
// disable v-sync
wglSwapIntervalEXT(0);
std::cout << "Video card supports WGL_EXT_swap_control." << std::endl;
}
}
#else // for linux, do not need to get function pointers, it is up-to-date
if(glInfo.isExtensionSupported("GL_ARB_framebuffer_object"))
{
fboSupported = fboUsed = true;
std::cout << "Video card supports GL_ARB_framebuffer_object." << std::endl;
}
else
{
fboSupported = fboUsed = false;
std::cout << "Video card does NOT support GL_ARB_framebuffer_object." << std::endl;
}
#endif
if(fboSupported)
{
// create a MSAA framebuffer object
// NOTE: All attachment images must have the same # of samples.
// Ohterwise, the framebuffer status will not be completed.
glGenFramebuffers(1, &fboMsaaId);
glBindFramebuffer(GL_FRAMEBUFFER, fboMsaaId);
// create a MSAA renderbuffer object to store color info
glGenRenderbuffers(1, &rboColorId);
glBindRenderbuffer(GL_RENDERBUFFER, rboColorId);
glRenderbufferStorageMultisample(GL_RENDERBUFFER, msaaCount, GL_RGB8, TEXTURE_WIDTH, TEXTURE_HEIGHT);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
// create a MSAA renderbuffer object to store depth info
// NOTE: A depth renderable image should be attached the FBO for depth test.
// If we don't attach a depth renderable image to the FBO, then
// the rendering output will be corrupted because of missing depth test.
// If you also need stencil test for your rendering, then you must
// attach additional image to the stencil attachement point, too.
glGenRenderbuffers(1, &rboDepthId);
glBindRenderbuffer(GL_RENDERBUFFER, rboDepthId);
glRenderbufferStorageMultisample(GL_RENDERBUFFER, msaaCount, GL_DEPTH_COMPONENT, TEXTURE_WIDTH, TEXTURE_HEIGHT);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
// attach msaa RBOs to FBO attachment points
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rboColorId);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rboDepthId);
// create a normal (no MSAA) FBO to hold a render-to-texture
glGenFramebuffers(1, &fboId);
glBindFramebuffer(GL_FRAMEBUFFER, fboId);
glGenRenderbuffers(1, &rboId);
glBindRenderbuffer(GL_RENDERBUFFER, rboId);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, TEXTURE_WIDTH, TEXTURE_HEIGHT);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
// attach a texture to FBO color attachement point
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureId, 0);
// attach a rbo to FBO depth attachement point
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rboId);
//@@ disable color buffer if you don't attach any color buffer image,
//@@ for example, rendering the depth buffer only to a texture.
//@@ Otherwise, glCheckFramebufferStatus will not be complete.
//glDrawBuffer(GL_NONE);
//glReadBuffer(GL_NONE);
// check FBO status
printFramebufferInfo(fboMsaaId);
bool status = checkFramebufferStatus(fboMsaaId);
if(!status)
fboUsed = false;
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
// start timer, the elapsed time will be used for rotating the teapot
timer.start();
// the last GLUT call (LOOP)
// window will be shown and display callback is triggered by events
// NOTE: this call never return main().
glutMainLoop(); /* Start GLUT event-processing loop */
return 0;
}
/* This is where execution begins */
int STDCALL WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR szCmdLine, int sw)
{
char *appname;
char *ptr;
int i;
FILE *fp;
char **argv;
int argc;
/*
* Direct Draw has a nasty bug where a file that is opened before
* Direct Draw is invoked, *stays* open until the system is rebooted.
* So we need to get Direct Draw loaded before we open any files.
*/
{
HANDLE h;
h = LoadLibrary("DDRAW.DLL");
if(h)
FreeLibrary(LoadLibrary("DDRAW.DLL"));
}
/* FIXME:
* fprintf needs to be remapped to a windows function, otherwise when
* executor dies the user has no idea why it just vanished.
*/
fp = freopen("stdout.txt", "w", stdout);
#if !defined(stdout)
if(!fp)
stdout = fopen("stdout.txt", "w");
#else
if(!fp)
*stdout = *fopen("stdout.txt", "w");
#endif
setbuf(stdout, 0);
fp = freopen("stderr.txt", "w", stderr);
#if !defined(stderr)
if(!fp)
stderr = fopen("stderr.txt", "w");
#else
if(!fp)
*stderr = *fopen("stderr.txt", "w");
#endif
setbuf(stderr, 0);
paramline_to_argcv(GetCommandLine(), &argc, &argv);
/* Get the class name from argv[0] */
/* Basename... */
if((ptr = strrchr(argv[0], '\\')) == NULL)
appname = argv[0];
else
appname = ptr + 1;
/* minus extension... */
if((ptr = strrchr(appname, '.')) == NULL)
i = strlen(appname);
else
i = (ptr - appname);
/* equals appname! */
ptr = (char *)alloca(i + 1);
strncpy(ptr, appname, i);
ptr[i] = '\0';
appname = ptr;
/* Load SDL dynamic link library */
if(SDL_Init(0) < 0)
{
fprintf(stderr, "WinMain() error: %s\n", SDL_GetError());
return (false);
}
atexit(SDL_Quit);
/* Create and register our class, then run main code */
if(SDL_RegisterApp(appname, CS_BYTEALIGNCLIENT, hInst) < 0)
{
fprintf(stderr, "WinMain() error: %s\n", SDL_GetError());
return (false);
}
SDL_main(argc, argv);
exit(0);
}
void
mod_1337(void)
{
FILE *f;
int i, j, nnlines, nchars = 0;
char c, *act;
f = fopen(FILENAME_1337, "r");
while(1) {
c = getc(f);
if(feof(f)) break;
if((i=conv_ind(c)) == -1) goto err;
if(getc(f)!=':') goto err;
if(getc(f)!='\n') goto err;
nnlines = 0;
conv_tab[i].n = 0;
do {
c = getc(f);
nchars++;
if(c=='\n') {
if(nnlines==0)
conv_tab[i].n++;
else
nchars--;
nnlines++;
} else {
nnlines = 0;
}
} while(nnlines<2 && !feof(f));
}
act = conv_buf = (char *) malloc(nchars*sizeof(char));
CHECK_MALLOC(conv_buf);
atexit(conv_buf_free);
rewind(f);
while(1) {
c = getc(f);
if(feof(f)) break;
if((i=conv_ind(c)) == -1) goto err;
if(getc(f)!=':') goto err;
if(getc(f)!='\n') goto err;
conv_tab[i].beg = act;
for(j=0; j<conv_tab[i].n; j++) {
while((*act=getc(f)) != '\n')
act++;
*act = '\0';
act++;
}
if(getc(f)!='\n' && !feof(f)) goto err;
}
fclose(f);
mod_add(&leet);
return;
err:
fclose(f);
puts("Error loading module \"1337\"");
}
int main(int argc, char **argv) {
Q_UNUSED(argc);
Q_UNUSED(argv);
atexit(exitHelper);
KCmdLineArgs::init(argc, argv, "testeqparser", "testeqparser", "testeqparser", "1.0.0.0");
KApplication app(false, false);
// Numbers
test("0", 1.0, 0.0);
test("1.0", 2.0, 1.0);
test(".2", 0.0, .2);
test("1e1", 0.0, 1e1);
test("1e+1", 0.0, 1e+1);
test("1e-1", 0.0, 1e-1);
test("1E1", 0.0, 1E1);
test("1E+1", 0.0, 1E+1);
test("1E-1", 0.0, 1E-1);
test("0.2e1", 0.0, 0.2e1);
test("01", 0.0, 1);
test("0.10", 0.0, 0.1);
test("01.", 0.0, 1);
test("1.", 0.0, 1.0);
test("1.0E5", 0.0, 1.0E5);
test("1.0E+5", 0.0, 1.0E+5);
test("1.0E-5", 0.0, 1.0E-5);
test("1.E5", 0.0, 1.0E5);
test("1.E+5", 0.0, 1.0E+5);
test("1.E-5", 0.0, 1.0E-5);
test("0.1000", 0.0, 0.1000);
test(".1000", 0.0, .1000);
testNotEqual("E+5", 0.0, 0e5); // this will actually be 2.7128182846 + 5
testNotEqual("E+5", 0.0, 1e5); // this will actually be 2.7182882846 + 5
testNotEqual("E-5", 0.0, 0e-5); // this will actually be 2.7182882846 - 5
testNotEqual("E-5", 0.0, 1e-5); // this will actually be 2.7182882846 - 5
testParseFail(".");
testParseFail("E5");
testParseFail(".E5");
testParseFail("1E5.0");
testParseFail("1E+5.0");
testParseFail("1E5.");
testParseFail("1E+5.");
// Basics
test("x", -1.0, -1.0);
test("-x", -1.0, 1.0);
test("x^2", -1.0, 1.0);
test(" x^2", -1.0, 1.0);
test(" x^2 ", -1.0, 1.0);
test("x^2 ", -1.0, 1.0);
test("x^2 + x^2", -1.0, 2.0);
test("y", 0.0, NOPOINT);
test("foo()", 0.0, NOPOINT);
test("foo(1.0, 2.0, 3.0)", 0.0, NOPOINT);
// Order of evaluation and parser issues
test("-x^2", 2.0, -4.0);
test("(-x)^2", 2.0, 4.0);
test("-(x^2)", 2.0, -4.0);
test("(-x^2)", 2.0, -4.0);
test("x*x+5", 2.0, 9.0);
test("5+x*x", 2.0, 9.0);
test("5*4/2*5", 1.0, 50.0);
test("asin(sin(x))", 3.14159265358979323, 0.0);
test("x^(1/2)", 2.0, sqrt(2.0));
test("x^(1/2)*2", 2.0, 2.0*sqrt(2.0));
test("(1/2)*x^2+3*x-5", 1.0, -1.5);
test("2^3^4", 0.0, 2417851639229258349412352.0);
test("sin(x)^2", 0.5*3.14159265358979323, 1.0);
test("(2)^(3)", 0.0, 8);
test("(2*3)^(3*4)", 0.0, 2176782336.0);
test("sin(x^2)", sqrt(3.14159265358979323), 0.0);
test("5*4/2", 0.0, 10.0);
test("5/4*2", 0.0, 2.5);
test("10%2", 0.0, 0.0);
test("10.5%2", 0.0, 0.5);
test("0%2", 0.0, 0.0);
test("2%0", 0.0, NOPOINT);
test("--x", 1.0, 1.0);
test("--x", -1.0, -1.0);
test("---x", -1.0, 1.0);
test("---x", 1.0, -1.0);
// Constants
test("e", 0.0, 2.7128182846);
test("pi", 0.0, 3.1415926536);
// Functions
test("sin()", 0.0, NOPOINT);
test("sin(0.0)", 0.0, 0.0);
test("sin(3.14159265358979323)", 0.0, 0.0);
test("sin(3.14159265358979323/2.00000000000000000000000000)", 0.0, 1.0);
test("cos()", 0.0, NOPOINT);
test("cos(0.0)", 0.0, 1.0);
test("cos(3.14159265358979323)", 0.0, -1.0);
test("cos(3.14159265358979323/2.00000000000000000000000000)", 0.0, 0.0);
test("abs(sec(x) - 1/cos(x)) < 0.000000001", 0.2332744, 1.0);
test("abs(csc(x) - 1/sin(x)) < 0.000000001", 0.2332744, 1.0);
test("abs(cot(x) - 1/tan(x)) < 0.000000001", 0.2332744, 1.0);
test("abs(0.0)", 0.0, 0.0);
test("abs(x)", 1.0, 1.0);
test("abs(x)", -1.0, 1.0);
test("abs(x)", NOPOINT, NOPOINT);
test("abs(x)", INF, INF);
test("abs(x)", -INF, INF);
test("abs(-0.000000000001)", 0.0, 0.000000000001);
test("cos(acos(x))", 0.3875823288, 0.3875823288, 0.0000000001);
test("acos(cos(x))", 2.3875823288, 2.3875823288, 0.0000000001);
test("asin(sin(x))", 0.7540103248, 0.7540103248, 0.0000000001);
test("sin(asin(x))", 0.3875823288, 0.3875823288, 0.0000000001);
test("tan(atan(x))", 2.3875823288, 2.3875823288, 0.0000000001);
test("atan(tan(x))", 0.3875823288, 0.3875823288, 0.0000000001);
test("sqrt(4) == 2.0", 0.0, 1.0);
test("sqrt(0) == 0.0", 0.0, 1.0);
test("sqrt(-1)", 0.0, NOPOINT);
test("sqrt(2)", 0.0, 1.4142135623730951);
test("cbrt(0.0) == 0.0", 0.0, 1.0);
test("cbrt(8.0) == 2.0", 0.0, 1.0);
test("cbrt(-1)", 0.0, -1.0);
test("cbrt(2)", 0.0, 1.2599210498948734);
// TODO: cosh, exp, log, ln, sinh, tanh
// Expressions / Comparison
test("0.0>0.0", 0.0, 0.0);
test("0.0>=0.0", 0.0, 1.0);
test("0.0<0.0", 0.0, 0.0);
test("0.0<=0.0", 0.0, 1.0);
test("0.0=0.0", 0.0, 1.0);
test("0.0!=0.0", 0.0, 0.0);
test("1.0!=0.0", 0.0, 1.0);
test("sin(1.0)!=sin(0.0)", 0.0, 1.0);
test("sin()!=sin()", 0.0, 1.0);
test("0.0==0.0", 0.0, 1.0);
test("1.0>0.0", 0.0, 1.0);
test("1.0>=0.0", 0.0, 1.0);
test("0.0>1.0", 0.0, 0.0);
test("0.0>=1.0", 0.0, 0.0);
test("1.0<0.0", 0.0, 0.0);
test("1.0<=0.0", 0.0, 0.0);
test("0.0<1.0", 0.0, 1.0);
test("0.0<=1.0", 0.0, 1.0);
test("(0.0/0.0)==(0.0/0.0)", 0.0, 0.0);
test("(0.0/0.0)==(1.0/0.0)", 0.0, 0.0);
test("(1.0/0.0)==(1.0/0.0)", 0.0, 1.0); // inf == inf
test("(1.0/0.0)==-(1.0/0.0)", 0.0, 0.0);
test("(0.0/0.0)==-(1.0/0.0)", 0.0, 0.0);
test("(1.0/0.0)==(0.0/0.0)", 0.0, 0.0);
test("1&&1", 0.0, 1.0);
test("1&&0", 0.0, 0.0);
test("0&&1", 0.0, 0.0);
test("0&&2", 0.0, 0.0);
test("3&&2", 0.0, 1.0);
test("1||1", 0.0, 1.0);
test("0||1", 0.0, 1.0);
test("1||0", 0.0, 1.0);
test("0||0", 0.0, 0.0);
test("2||4", 0.0, 1.0);
test("1||(2&&0)", 0.0, 1.0);
test("(1||2)&&0", 0.0, 0.0);
test("1||2&&0", 0.0, 1.0);
test("2&&0||1", 0.0, 1.0);
test("2&&1||0", 0.0, 1.0);
test("0||1&&0", 0.0, 0.0);
test("1.0 == (1.0 == 1.0)", 0.0, 1.0);
test("1.0 != (1.0 == 0.0)", 0.0, 1.0);
test("1.0 != (1.0 == 1.0)", 0.0, 0.0);
test("0.0 == (1.0 == 0.0)", 0.0, 1.0);
test("-1==1", 0.0, 0.0);
test("-1==-1", 0.0, 1.0);
test("1==-1", 0.0, 0.0);
test("1!=-1", 0.0, 1.0);
test("-1!=1", 0.0, 1.0);
test("-1!=-1", 0.0, 0.0);
test("!0.0", 0.0, 1.0);
test("!1.0", 0.0, 0.0);
test("!-1.0", 0.0, 0.0);
test("!2.0", 0.0, 0.0);
test("!x", INF, 0.0);
test("!x", NOPOINT, 1.0);
test("!(1 > 2)", 0.0, 1.0);
test("!1.0 > -1.0", 0.0, 1.0); // (!1.0) > -1.0
test("!!x", 1.0, 1.0);
test("!!!x", 1.0, 0.0);
test("!!!!x", 1.0, 1.0);
// Bit operations
test("32&4", 0.0, 0.0);
test("32&4|2", 0.0, 2.0);
test("32|4&2", 0.0, 0.0);
test("32|4", 0.0, 36.0);
test("0&257", 0.0, 0.0);
test("257&0", 0.0, 0.0);
test("257|0", 0.0, 257.0);
test("0|257", 0.0, 257.0);
test("-1|257", 0.0, -1);
test("257|-1", 0.0, -1);
// Scalars
new KstScalar(KstObjectTag("test1"), 0L, 1.0, true);
new KstScalar(KstObjectTag("test2"), 0L, 0.0, true);
new KstScalar(KstObjectTag("test3"), 0L, -1.0, true);
new KstScalar(KstObjectTag("test4"), 0L, NOPOINT, true);
new KstScalar(KstObjectTag("test5"), 0L, INF, true);
new KstScalar(KstObjectTag("test6"), 0L, -INF, true);
test("[test1]", 0.0, 1.0);
test("[test4]", 0.0, NOPOINT);
test("[test4] - [test4]", 0.0, NOPOINT);
test("[test4] - [test5]", 0.0, NOPOINT);
test("[test4]*[test5]", 0.0, NOPOINT);
test("[sdf]", 0.0, NOPOINT);
test("[=10+10]", 0.0, 20.0);
// Vectors
KstVector::generateVector(0, 1.0, 10, KstObjectTag("1"));
KstVector::generateVector(0, 1.0, 10, KstObjectTag("V1"));
KstVector::generateVector(1.0, 2.0, 10, KstObjectTag("V2"));
KstVector::generateVector(0, 1.0, 2, KstObjectTag("V3"));
KstVector::generateVector(-1.0, 1.0, 1000, KstObjectTag("V4"));
KstVector::generateVector(-1.0, 1.0, 1000, KstObjectTag("V5-%+-_!"));
test("[V2] - [V1]", 0.0, 1.0);
test("[V2[9]]", 0.0, 2.0);
test("[V2[5+4]]", 0.0, 2.0);
test("[V2[]]", 0.0, 1.0);
test("2*sin([V5-%+-_!])", 0.0, -1.6829419696157930);
// TODO: interpolation, more vector combinations
// Plugins
test("2*plugin(Bin, [V4], 12)", 1.0, -1.9779779779779778);
test("4*plugin(Bin, [V4], x)", 5.0, -3.9839839839839839);
test("-3*plugin(Bin, x, 12)", 2.0, NOPOINT);
xVector = KstVector::generateVector(0, 100, 2000, KstObjectTag("XVector"));
test("-3*plugin(Bin, x, 12)", 2.0, -0.8254127063531767);
test("-3*plugin(Bin, y, 12)", 2.0, NOPOINT);
// TODO: float notation
// Combinations
test("1|0&&0", 0.0, 0.0);
test("0&&0|1", 0.0, 0.0);
test("0&&1|0", 0.0, 0.0);
test("0||1&1", 0.0, 1.0);
test("0||2&1", 0.0, 0.0);
test("2&1||0", 0.0, 0.0);
test("1-1||0", 0.0, 0.0);
test("2-2||0", 0.0, 0.0);
test("0||2-2", 0.0, 0.0);
test("8|2*2", 0.0, 12.0);
test("2*2|8", 0.0, 12.0);
test("[V1] > 0.0", 0.0, 0.0);
test("[V1] > -1.0", 0.0, 1.0);
test("[1] > 0.0", 0.0, 0.0);
test("[1] > -1.0", 0.0, 1.0);
test("-([V1]*sin([V1]*[V2])+[V3]*cos([V3]*[V3]))", 0.0, 0.0);
test("[V3] * -1", 0.0, 0.0);
// Wrap a testcase with this and run bison with -t in order to get a trace of the parse stack
#if 0
yydebug = 1;
yydebug = 0;
#endif
// Errors:
testParseFail("");
testParseFail(" ");
testParseFail("\t");
testParseFail(" \t \t");
testParseFail("[]");
testParseFail("[[]");
testParseFail("[]]");
testParseFail("]");
testParseFail("[");
testParseFail("][");
testParseFail("[][");
testParseFail("foo(, 3)");
testParseFail("foo(3,)");
testParseFail("foo(3,,5)");
testParseFail("foo([])");
testParseFail("foo(4, [])");
testParseFail("/");
testParseFail("/2");
testParseFail("2/");
testParseFail("2//2");
testParseFail("%");
testParseFail("%2");
testParseFail("2%");
testParseFail("2%%2");
testParseFail("|");
testParseFail("||");
testParseFail("|2");
testParseFail("2|");
testParseFail("||2");
testParseFail("2||");
testParseFail("2|||2");
testParseFail("&");
testParseFail("&&");
testParseFail("&2");
testParseFail("2&");
testParseFail("&&2");
testParseFail("2&&");
testParseFail("2&&&2");
testParseFail("*");
testParseFail("*2");
testParseFail("2*");
testParseFail("2**2");
testParseFail("^");
testParseFail("^2");
testParseFail("2^^2");
testParseFail("2^");
testParseFail("+");
testParseFail("+2");
testParseFail("2+");
testParseFail("2++2");
testParseFail("-");
testParseFail("2-");
testParseFail("-2-");
testParseFail("2!");
testParseFail("!");
testParseFail("()");
testParseFail("2()");
testParseFail("()2");
testParseFail("_");
testParseFail("#");
testParseFail("$");
testParseFail(")");
testParseFail("(");
testParseFail(")(");
testParseFail("2&|2");
testParseFail("2&&||2");
testParseFail("2&&+2");
testParseFail("2+&&2");
testParseFail("2*&&2");
testParseFail("2&&*2");
testParseFail("2<>2");
testParseFail("2=<2");
testParseFail("2=>2");
testParseFail("2><2");
testParseFail("<");
testParseFail("<2");
testParseFail("2<");
testParseFail("2<<2");
testParseFail(">");
testParseFail(">2");
testParseFail("2>");
testParseFail("2>>2");
testParseFail(">=");
testParseFail(">=2");
testParseFail("2>=");
testParseFail("2>=>=2");
testParseFail("<=");
testParseFail("<=2");
testParseFail("2<=");
testParseFail("2<=<=2");
testParseFail("2<==2");
testParseFail(",");
testParseFail(",2");
testParseFail("2,"); // Doesn't give a specific error - how to catch this?
testParseFail("2*sin(x");
testParseFail("2*sin(x)()");
testText("3*x", "3*x");
testText("(3*x)", "(3*x)");
testText("3*(x)", "3*x");
testText("((3*x))", "(3*x)");
testText(" ((3 * x)) ", "(3*x)");
testText(" ((3 * x)) ", "(3*x)");
testText("(-3)", "(-3)");
testText("(x)", "x");
testText("(3*(-(x+5)))", "(3*(-(x+5)))");
testText("(sin((x)))", "sin(x)");
exitHelper();
if (rc == KstTestSuccess) {
printf("All tests passed!\n");
}
return -rc;
}
int main(int argc, char** argv) {
char SQLq[2048];
/* exit routine */
atexit (exitProc);
/* check arguments */
if (readArgs(argc, argv) == FALSE) {
fprintf (stderr, "You have to provide DB-Connection infos and the input directory with the XML-Files.\n");
return EXIT_FAILURE;
}
/* connect to Database, keep connection Idle */
if (!connectDB())
return EXIT_FAILURE;
setlocale (LC_CTYPE,"");
/* Drop old tables if they exist */
bzero (SQLq, 2048);
sprintf (SQLq, db_DROP_TABLE, db_tvtable);
if (mysql_real_query(mysql_conn, SQLq, strlen(SQLq)) != 0) {
fprintf (stderr, "Error while droping Table:%s.\n\t%s", db_tvtable, mysql_error(mysql_conn));
}
printD ("Dropped Table:%s\n", db_tvtable);
bzero (SQLq, 2048);
sprintf (SQLq, db_CREATE_TVTABLE, db_tvtable);
if (mysql_real_query(mysql_conn, SQLq, strlen(SQLq)) != 0) {
fprintf (stderr, "Error while creating Table:%s.\n\t%s", db_tvtable, mysql_error(mysql_conn));
}
printD ("Created Table:%s\n", db_tvtable);
/****TVEND****/
bzero (SQLq, 2048);
sprintf (SQLq, db_DROP_TABLE, db_movietable);
if (mysql_real_query(mysql_conn, SQLq, strlen(SQLq)) != 0) {
fprintf (stderr, "Error while droping Table:%s.\n\t%s", db_tvtable, mysql_error(mysql_conn));
}
printD ("Dropped Table:%s\n", db_movietable);
bzero (SQLq, 2048);
sprintf (SQLq, db_CREATE_MOVIETABLE, db_movietable);
if (mysql_real_query(mysql_conn, SQLq, strlen(SQLq)) != 0) {
fprintf (stderr, "Error while creating Table:%s.\n\t%s", db_movietable, mysql_error(mysql_conn));
}
printD ("Created Table:%s\n", db_movietable);
/****MOVIEEND****/
if (db_newstable) {
bzero (SQLq, 2048);
sprintf (SQLq, db_DROP_TABLE, db_newstable);
if (mysql_real_query(mysql_conn, SQLq, strlen(SQLq)) != 0) {
fprintf (stderr, "Error while droping Table:%s.\n\t%s", db_newstable, mysql_error(mysql_conn));
}
printD ("Dropped Table:%s\n", db_newstable);
bzero (SQLq, 2048);
sprintf (SQLq, db_CREATE_NEWS, db_newstable);
if (mysql_real_query(mysql_conn, SQLq, strlen(SQLq)) != 0) {
fprintf (stderr, "Error while creating Table:%s.\n\t%s", db_newstable, mysql_error(mysql_conn));
}
printD ("Created Table:%s\n", db_newstable);
}
/****NEWSEND****/
/* enter Mainloop and walk thru directory... */
mainLoop();
printD ("Mainloop returned gracefully, cleaning up the mess and leaving...\n");
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
database_t *db;
char *uri;
int session_id;
bool start, success;
/* enable attest debugging hook */
dbg = stderr_dbg;
atexit(library_deinit);
/* initialize library */
if (!library_init(NULL, "imv_policy_manager"))
{
exit(SS_RC_LIBSTRONGSWAN_INTEGRITY);
}
if (!lib->plugins->load(lib->plugins,
lib->settings->get_str(lib->settings, "imv_policy_manager.load",
"sqlite")))
{
exit(SS_RC_INITIALIZATION_FAILED);
}
if (argc < 3)
{
usage();
exit(SS_RC_INITIALIZATION_FAILED);
}
if (streq(argv[1], "start"))
{
start = TRUE;
}
else if (streq(argv[1], "stop"))
{
start = FALSE;
}
else
{
usage();
exit(SS_RC_INITIALIZATION_FAILED);
}
session_id = atoi(argv[2]);
/* attach IMV database */
uri = lib->settings->get_str(lib->settings,
"imv_policy_manager.database",
lib->settings->get_str(lib->settings,
"charon.imcv.database",
lib->settings->get_str(lib->settings,
"libimcv.database", NULL)));
if (!uri)
{
fprintf(stderr, "database uri not defined.\n");
exit(SS_RC_INITIALIZATION_FAILED);
}
db = lib->db->create(lib->db, uri);
if (!db)
{
fprintf(stderr, "opening database failed.\n");
exit(SS_RC_INITIALIZATION_FAILED);
}
if (start)
{
success = policy_start(db, session_id);
}
else
{
success = policy_stop(db, session_id);
}
db->destroy(db);
fprintf(stderr, "imv_policy_manager %s %s\n", start ? "start" : "stop",
success ? "successful" : "failed");
exit(EXIT_SUCCESS);
}
int
main( int argc, char* argv[] )
{
srand(time(nullptr));
LabData lab( 31, 31 );
// Setup SDL related stuff
SDL_Init( SDL_INIT_VIDEO );
atexit( SDL_Quit );
atexit( IMG_Quit );
size_t hwin = 17;
size_t wwin = 16;
Term::SDL::Context term( wwin, hwin );
term.Tilemap( "tileset.png" );
SDL_Surface* screen = SDL_SetVideoMode(
term.Framebuffer().Width() * term.TileWidth(),
term.Framebuffer().Height() * term.TileHeight(),
32, SDL_SWSURFACE );
term.RenderTarget( screen );
Term::Char clearChar('\0');
clearChar.PriColor( Term::Color::Black );
clearChar.SecColor( Term::Color::Black );
term.Framebuffer().ClearChar( clearChar );
SDL_EnableKeyRepeat( 100, 100 ); // Basically the movementspeed of the player.
Term::TTY tty( term.Framebuffer() );
GenerateLabyrinth( lab );
MakePrettySymbols( lab );
bool running = true;
while(running)
{
SDL_Event event;
while( SDL_PollEvent(&event) ) switch( event.type )
{
case SDL_QUIT:
running = false; break;
case SDL_KEYDOWN: switch( event.key.keysym.sym )
{
case SDLK_ESCAPE:
running = false; break;
case SDLK_UP:
MovePlayer( lab, 0, -1 ); break;
case SDLK_DOWN:
MovePlayer( lab, 0, 1 ); break;
case SDLK_LEFT:
MovePlayer( lab, -1, 0 ); break;
case SDLK_RIGHT:
MovePlayer( lab, 1, 0 ); break;
default: break;
} break;
}
if( lab.win )
{
std::string winstr( "!!!WIN!!!" );
int x = rand() % (term.Framebuffer().Width()+winstr.length()) - winstr.length();
int y = rand() % (term.Framebuffer().Height()+winstr.length()) - winstr.length();
tty.PriColor( RandomColor() );
tty.SecColor( RandomColor() );
tty.Place(x,y).Put( winstr );
}
else
{
term.Framebuffer().Clear();
term.Framebuffer().Copy( lab.symbuf, 0, 1,
-(term.Framebuffer().Width()/2) + lab.xplayer,
-(term.Framebuffer().Height()/2) + lab.yplayer,
term.Framebuffer().Width(), term.Framebuffer().Height() );
tty.Place( term.Framebuffer().Width()/2, term.Framebuffer().Height()/2+1 );
tty.PriColor( Term::Color::White );
tty.SecColor( Term::Color::Black );
tty.Put( 1 );
for( auto itoken : lab.tokens )
{
tty.Place(
(itoken % lab.width) +(term.Framebuffer().Width())/2 - lab.xplayer ,
(itoken / lab.width) +(term.Framebuffer().Height()/2) - lab.yplayer +1 );
tty.Put( 9 );
}
tty.Place(0,0).PriColor( Term::Color::Black ).SecColor( Term::Color::White );
if( lab.door == 0 )
{
tty.Put( "Tokens left: " );
std::stringstream ss;
ss << lab.tokens.size();
tty.Put( ss.str() );
}
else
{
tty.Put( "Find the door!" );
tty.Place(
lab.door % lab.width + term.Framebuffer().Width()/2 - lab.xplayer,
lab.door / lab.width + term.Framebuffer().Height()/2 + 1 - lab.yplayer );
tty.Put( 239 );
}
}
term.Print();
SDL_Flip(screen);
SDL_Delay(50);
}
}
static void do_startup( void )
{
#else
static BOOL WINAPI _RawDllMain( HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved )
{
(void)hinstDLL; /* avoid warnings */
(void)lpvReserved; /* avoid warnings */
switch (fdwReason)
{
case DLL_PROCESS_ATTACH:
{
#endif
#if OSL_DEBUG_LEVEL < 2
/* Suppress file error messages from system like "Floppy A: not inserted" */
SetErrorMode( SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS );
#endif
/* initialize global mutex */
g_Mutex = osl_createMutex();
/* initialize "current directory" mutex */
g_CurrentDirectoryMutex = osl_createMutex();
g_dwTLSTextEncodingIndex = TlsAlloc();
InitializeCriticalSection( &g_ThreadKeyListCS );
//We disable floating point exceptions. This is the usual state at program startup
//but on Windows 98 and ME this is not always the case.
_control87(_MCW_EM, _MCW_EM);
#ifdef __MINGW32__
atexit(do_cleanup);
}
void do_cleanup( void )
{
#else
break;
}
case DLL_PROCESS_DETACH:
#endif
WSACleanup( );
TlsFree( g_dwTLSTextEncodingIndex );
DeleteCriticalSection( &g_ThreadKeyListCS );
osl_destroyMutex( g_Mutex );
osl_destroyMutex( g_CurrentDirectoryMutex );
#ifndef __MINGW32__
/*
On a product build memory management finalization might
cause a crash without assertion (assertions off) if heap is
corrupted. But a crash report won't help here because at
this point all other threads have been terminated and only
ntdll is on the stack. No chance to find the reason for the
corrupted heap if so.
So annoying the user with a crash report is completely useless.
*/
#ifndef DBG_UTIL
__try
#endif
{
/* cleanup locale hashtable */
rtl_locale_fini();
/* finalize memory management */
rtl_memory_fini();
rtl_cache_fini();
rtl_arena_fini();
}
#ifndef DBG_UTIL
__except( EXCEPTION_EXECUTE_HANDLER )
{
}
#endif
break;
}
return TRUE;
#endif
}
int main(
int argc,
char *argv[])
{
BACNET_ADDRESS src = {
0
}; /* address where message came from */
uint16_t pdu_len = 0;
unsigned timeout = 100; /* milliseconds */
time_t total_seconds = 0;
time_t elapsed_seconds = 0;
time_t last_seconds = 0;
time_t current_seconds = 0;
time_t timeout_seconds = 0;
if (argc < 2) {
printf("Usage: %s address [DNET ID Len Info]\r\n",
filename_remove_path(argv[0]));
return 0;
}
if ((argc > 1) && (strcmp(argv[1], "--help") == 0)) {
printf("Send BACnet Initialize-Routing-Table message to a network\r\n"
"and wait for responses. Displays their network information.\r\n"
"\r\n" "address:\r\n"
"MAC address in xx:xx:xx:xx:xx:xx format or IP x.x.x.x:port\r\n"
"DNET ID Len Info:\r\n" "Port-info data:\r\n" " DNET:\r\n"
" Destination network number 0-65534\r\n" " ID:\r\n"
" Port Identifier number 0-255\r\n" " Info:\r\n"
" Octet string of data, up to 255 octets\r\n"
"To query the complete routing table, do not include any port-info.\r\n"
"To query using Initialize-Routing-Table message to 192.168.0.18:\r\n"
"%s 192.168.0.18:47808\r\n", filename_remove_path(argv[0]));
return 0;
}
/* decode the command line parameters */
address_parse(&Target_Router_Address, argc - 1, &argv[1]);
if (argc > 2) {
/* FIXME: add port info parse */
/* BACNET_ROUTER_PORT *router_port_list
Target_Router_Port_List
ports_parse(&router_port[0], argc-2, &argv[2]);
Target_Router_Port_List = router_port[0];
*/
}
/* setup my info */
Device_Set_Object_Instance_Number(BACNET_MAX_INSTANCE);
Init_Service_Handlers();
address_init();
dlenv_init();
atexit(datalink_cleanup);
/* configure the timeout values */
last_seconds = time(NULL);
timeout_seconds = apdu_timeout() / 1000;
/* send the request */
Send_Initialize_Routing_Table(&Target_Router_Address, DNET_list);
/* loop forever */
for (;;) {
/* increment timer - exit if timed out */
current_seconds = time(NULL);
/* returns 0 bytes on timeout */
pdu_len = datalink_receive(&src, &Rx_Buf[0], MAX_MPDU, timeout);
/* process */
if (pdu_len) {
My_NPDU_Handler(&src, &Rx_Buf[0], pdu_len);
}
if (Error_Detected)
break;
/* increment timer - exit if timed out */
elapsed_seconds = current_seconds - last_seconds;
if (elapsed_seconds) {
#if defined(BACDL_BIP) && BBMD_ENABLED
bvlc_maintenance_timer(elapsed_seconds);
#endif
}
total_seconds += elapsed_seconds;
if (total_seconds > timeout_seconds)
break;
/* keep track of time for next check */
last_seconds = current_seconds;
}
return 0;
}
int mysetup(int argc, char **argv)
{
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
fprintf(stderr, "Unable to init SDL: %s\n", SDL_GetError());
return 1;
}
atexit(SDL_Quit);
screen = SDL_SetVideoMode(48 * FONT_W, 16 * FONT_H, 8, SDL_SWSURFACE);
if (screen == NULL) {
fprintf(stderr, "Unable to set video: %s\n", SDL_GetError());
return 1;
}
/* Set the window caption */
SDL_WM_SetCaption("Nascom II", "Nascom II");
#if 0
/* Populate the palette */
SDL_Color colors[256];
colors[0].r = colors[0].g = colors[0].b = 0;
colors[255].r = colors[255].b = 0;
colors[255].g = 255;
/* Set palette */
if (!SDL_SetColors(screen, colors, 0, 256)) {
fprintf(stderr, "Unable to create framebuffer palette: %s\n",
SDL_GetError());
screen = 0; //XXX should free it
return 1;
}
#endif
/* Load font */
nascom_font.surf =
SDL_CreateRGBSurfaceFrom(
nascom_font_raw,
8 /* width */,
256*16 /* height */,
1 /* depth */,
1 /* pitch */,
0 /* Rmask */,
1 /* Gmask */,
0 /* Bmask */,
0 /* Amask */);
nascom_font.w = FONT_W;
nascom_font.h = FONT_H;
nascom_font.h_pitch = FONT_H_PITCH;
if (!nascom_font.surf) {
perror("Couldn't load the font\n");
return 1;
}
nascom_font.surf = SDL_DisplayFormat(nascom_font.surf);
return 0;
}
int main(int argc, char **argv) {
if (enet_initialize() != 0) {
fprintf(stderr, "An error occurred while initializing ENet.\n");
return EXIT_FAILURE;
} else {
fprintf(stdout, "ENet initialized correctly.\n");
}
atexit(enet_deinitialize);
ENetAddress address;
ENetHost *server;
int eventStatus;
/* Bind the server to the default localhost. */
/* A specific host address can be specified by */
/* enet_address_set_host(&address, "x.x.x.x"); */
address.host = ENET_HOST_ANY;
address.port = SERVER_PORT;
server = enet_host_create(&address, MAX_CONN, 2, 0, 0);
if (server == NULL) {
fprintf(stderr, "An error occured while try to create an ENet server host.\n");
exit(EXIT_FAILURE);
} else {
fprintf(stdout, "ENet server created successfully.\n");
}
eventStatus = 1;
ENetEvent event;
while (1) {
eventStatus = enet_host_service(server, &event, 50000);
// If we had some event that interested us
if (eventStatus > 0) {
switch(event.type) {
case ENET_EVENT_TYPE_CONNECT:
printf("(Server) We got a new connection from %x\n",
event.peer->address.host);
break;
case ENET_EVENT_TYPE_RECEIVE:
printf("(Server) Message from client : %s\n", event.packet->data);
// Lets broadcast this message to all
enet_host_broadcast(server, 0, event.packet);
break;
case ENET_EVENT_TYPE_DISCONNECT:
printf("%s disconnected.\n", event.peer->data);
// Reset client's information
event.peer->data = NULL;
break;
case ENET_EVENT_TYPE_NONE:
printf("No event.\n");
break;
}
}
}
enet_host_destroy(server);
return 0;
}
static void
make_server_connections(void)
{
int i, wait_time;
/*
* Try to open the menuserver socket, if I can not, then set a flag
*/
if (open_server(MenuServerName) == -2) {
fprintf(stderr, "(HyperDoc) Warning: Not connected to FriCAS Server!\n");
MenuServerOpened = 0;
} else {
atexit(&clean_socket);
MenuServerOpened = 1;
}
/*
* If I have opened the MenuServer socket, then I should also try to open
* the SpadServer socket, so I can send stuff right to SPAD.
*/
if (MenuServerOpened) {
/*
* If I am a ht server, then I should not continue on unless I
* establish some sort of connection
*/
/*
* Modified on 11/20 so that it prints an error message every ten for
* ten tries at opeing the socket. If it fails all ten times, it
* gives up and exits.
*/
if (!is_fricas_server)
wait_time = 2;
else
wait_time = 1000;
for (i = 0, spad_socket = NULL; i < 2 && spad_socket == NULL; i++) {
spad_socket = connect_to_local_server(SpadServer,
MenuServer, wait_time);
if (is_fricas_server && spad_socket == NULL)
fprintf(stderr, "(HyperDoc) Error opening FriCAS server. Retrying ...\n");
else
i = 11;
}
if (! spad_socket) {
fprintf(stderr, "(HyperDoc) Couldn't connect to FriCAS server!\n");
if (!is_fricas_server)
MenuServerOpened = 0;
else {
fprintf(stderr, "(HyperDoc) Couldn't connect to FriCAS server!\n");
exit(-1);
}
}
else {
/*
* Do the same thing for the SessionServer
*/
for (i = 0, session_server = NULL; i < 2 && session_server == NULL
; i++) {
session_server =
connect_to_local_server(SessionServer, MenuServer,
wait_time);
if (is_fricas_server && session_server == NULL) {
fprintf(stderr,
"(HyperDoc) Error opening SessionServer, Retrying ...\n");
}
else
i = 11;
}
if (session_server == NULL) {
fprintf(stderr, "(HyperDoc) Connection attempt to session manager timed out.\n");
if (is_fricas_server) {
fprintf(stderr,
"(HyperDoc) Server unable to connect to session server\n");
exit(-1);
}
else {
MenuServerOpened = 0;
}
}
}
}
}
// xatexit schedules the exit-handler f to be run when the program exits.
void
xatexit(void (*f)(void))
{
atexit(f);
}
int main(int argc, char *argv[])
{
int retval = 0;
/*
Initialization
*/
log_add_output_maxlev(&main_stderr_log_out, LMT_ACTION);
log_add_output_all_levs(&main_dstream_no_stderr_log_out);
log_register_thread("main");
// Set locale. This is for forcing '.' as the decimal point.
std::locale::global(std::locale("C"));
// This enables printing all characters in bitmap font
setlocale(LC_CTYPE, "en_US");
/*
Parse command line
*/
// List all allowed options
core::map<std::string, ValueSpec> allowed_options;
allowed_options.insert("help", ValueSpec(VALUETYPE_FLAG,
"Show allowed options"));
allowed_options.insert("config", ValueSpec(VALUETYPE_STRING,
"Load configuration from specified file"));
allowed_options.insert("port", ValueSpec(VALUETYPE_STRING,
"Set network port (UDP)"));
allowed_options.insert("disable-unittests", ValueSpec(VALUETYPE_FLAG,
"Disable unit tests"));
allowed_options.insert("enable-unittests", ValueSpec(VALUETYPE_FLAG,
"Enable unit tests"));
allowed_options.insert("map-dir", ValueSpec(VALUETYPE_STRING,
"Same as --world (deprecated)"));
allowed_options.insert("world", ValueSpec(VALUETYPE_STRING,
"Set world path (implies local game) ('list' lists all)"));
allowed_options.insert("worldname", ValueSpec(VALUETYPE_STRING,
"Set world by name (implies local game)"));
allowed_options.insert("info", ValueSpec(VALUETYPE_FLAG,
"Print more information to console"));
allowed_options.insert("verbose", ValueSpec(VALUETYPE_FLAG,
"Print even more information to console"));
allowed_options.insert("trace", ValueSpec(VALUETYPE_FLAG,
"Print enormous amounts of information to log and console"));
allowed_options.insert("logfile", ValueSpec(VALUETYPE_STRING,
"Set logfile path ('' = no logging)"));
allowed_options.insert("gameid", ValueSpec(VALUETYPE_STRING,
"Set gameid (\"--gameid list\" prints available ones)"));
#ifndef SERVER
allowed_options.insert("speedtests", ValueSpec(VALUETYPE_FLAG,
"Run speed tests"));
allowed_options.insert("address", ValueSpec(VALUETYPE_STRING,
"Address to connect to. ('' = local game)"));
allowed_options.insert("random-input", ValueSpec(VALUETYPE_FLAG,
"Enable random user input, for testing"));
allowed_options.insert("server", ValueSpec(VALUETYPE_FLAG,
"Run dedicated server"));
allowed_options.insert("name", ValueSpec(VALUETYPE_STRING,
"Set player name"));
allowed_options.insert("password", ValueSpec(VALUETYPE_STRING,
"Set password"));
allowed_options.insert("go", ValueSpec(VALUETYPE_FLAG,
"Disable main menu"));
#endif
Settings cmd_args;
bool ret = cmd_args.parseCommandLine(argc, argv, allowed_options);
if(ret == false || cmd_args.getFlag("help") || cmd_args.exists("nonopt1"))
{
dstream<<"Allowed options:"<<std::endl;
for(core::map<std::string, ValueSpec>::Iterator
i = allowed_options.getIterator();
i.atEnd() == false; i++)
{
std::ostringstream os1(std::ios::binary);
os1<<" --"<<i.getNode()->getKey();
if(i.getNode()->getValue().type == VALUETYPE_FLAG)
{}
else
os1<<" <value>";
dstream<<padStringRight(os1.str(), 24);
if(i.getNode()->getValue().help != NULL)
dstream<<i.getNode()->getValue().help;
dstream<<std::endl;
}
return cmd_args.getFlag("help") ? 0 : 1;
}
/*
Low-level initialization
*/
// If trace is enabled, enable logging of certain things
if(cmd_args.getFlag("trace")){
dstream<<"Enabling trace level debug output"<<std::endl;
log_trace_level_enabled = true;
dout_con_ptr = &verbosestream; // this is somewhat old crap
socket_enable_debug_output = true; // socket doesn't use log.h
}
// In certain cases, output info level on stderr
if(cmd_args.getFlag("info") || cmd_args.getFlag("verbose") ||
cmd_args.getFlag("trace") || cmd_args.getFlag("speedtests"))
log_add_output(&main_stderr_log_out, LMT_INFO);
// In certain cases, output verbose level on stderr
if(cmd_args.getFlag("verbose") || cmd_args.getFlag("trace"))
log_add_output(&main_stderr_log_out, LMT_VERBOSE);
porting::signal_handler_init();
bool &kill = *porting::signal_handler_killstatus();
porting::initializePaths();
// Create user data directory
fs::CreateDir(porting::path_user);
init_gettext((porting::path_share+DIR_DELIM+".."+DIR_DELIM+"locale").c_str());
// Initialize debug streams
#ifdef RUN_IN_PLACE
std::string logfile = DEBUGFILE;
#else
std::string logfile = porting::path_user+DIR_DELIM+DEBUGFILE;
#endif
if(cmd_args.exists("logfile"))
logfile = cmd_args.get("logfile");
if(logfile != "")
debugstreams_init(false, logfile.c_str());
else
debugstreams_init(false, NULL);
infostream<<"logfile = "<<logfile<<std::endl;
infostream<<"path_share = "<<porting::path_share<<std::endl;
infostream<<"path_user = "******"gameid") && cmd_args.get("gameid") == "list")
{
std::set<std::string> gameids = getAvailableGameIds();
for(std::set<std::string>::const_iterator i = gameids.begin();
i != gameids.end(); i++)
dstream<<(*i)<<std::endl;
return 0;
}
// List worlds if requested
if(cmd_args.exists("world") && cmd_args.get("world") == "list"){
dstream<<"Available worlds:"<<std::endl;
std::vector<WorldSpec> worldspecs = getAvailableWorlds();
print_worldspecs(worldspecs, dstream);
return 0;
}
// Print startup message
infostream<<PROJECT_NAME<<
" with SER_FMT_VER_HIGHEST="<<(int)SER_FMT_VER_HIGHEST
<<", "<<BUILD_INFO
<<std::endl;
/*
Basic initialization
*/
// Initialize default settings
set_default_settings(g_settings);
// Initialize sockets
sockets_init();
atexit(sockets_cleanup);
/*
Read config file
*/
// Path of configuration file in use
std::string configpath = "";
if(cmd_args.exists("config"))
{
bool r = g_settings->readConfigFile(cmd_args.get("config").c_str());
if(r == false)
{
errorstream<<"Could not read configuration from \""
<<cmd_args.get("config")<<"\""<<std::endl;
return 1;
}
configpath = cmd_args.get("config");
}
else
{
core::array<std::string> filenames;
filenames.push_back(porting::path_user +
DIR_DELIM + "minetest.conf");
// Legacy configuration file location
filenames.push_back(porting::path_user +
DIR_DELIM + ".." + DIR_DELIM + "minetest.conf");
#ifdef RUN_IN_PLACE
// Try also from a lower level (to aid having the same configuration
// for many RUN_IN_PLACE installs)
filenames.push_back(porting::path_user +
DIR_DELIM + ".." + DIR_DELIM + ".." + DIR_DELIM + "minetest.conf");
#endif
for(u32 i=0; i<filenames.size(); i++)
{
bool r = g_settings->readConfigFile(filenames[i].c_str());
if(r)
{
configpath = filenames[i];
break;
}
}
// If no path found, use the first one (menu creates the file)
if(configpath == "")
configpath = filenames[0];
}
// Initialize random seed
srand(time(0));
mysrand(time(0));
/*
Run unit tests
*/
if((ENABLE_TESTS && cmd_args.getFlag("disable-unittests") == false)
|| cmd_args.getFlag("enable-unittests") == true)
{
run_tests();
}
/*
Game parameters
*/
// Port
u16 port = 30000;
if(cmd_args.exists("port"))
port = cmd_args.getU16("port");
else if(g_settings->exists("port"))
port = g_settings->getU16("port");
if(port == 0)
port = 30000;
// World directory
std::string commanded_world = "";
if(cmd_args.exists("world"))
commanded_world = cmd_args.get("world");
else if(cmd_args.exists("map-dir"))
commanded_world = cmd_args.get("map-dir");
else if(cmd_args.exists("nonopt0")) // First nameless argument
commanded_world = cmd_args.get("nonopt0");
else if(g_settings->exists("map-dir"))
commanded_world = g_settings->get("map-dir");
// World name
std::string commanded_worldname = "";
if(cmd_args.exists("worldname"))
commanded_worldname = cmd_args.get("worldname");
// Strip world.mt from commanded_world
{
std::string worldmt = "world.mt";
if(commanded_world.size() > worldmt.size() &&
commanded_world.substr(commanded_world.size()-worldmt.size())
== worldmt){
dstream<<"Supplied world.mt file - stripping it off."<<std::endl;
commanded_world = commanded_world.substr(
0, commanded_world.size()-worldmt.size());
}
}
// If a world name was specified, convert it to a path
if(commanded_worldname != ""){
// Get information about available worlds
std::vector<WorldSpec> worldspecs = getAvailableWorlds();
bool found = false;
for(u32 i=0; i<worldspecs.size(); i++){
std::string name = worldspecs[i].name;
if(name == commanded_worldname){
if(commanded_world != ""){
dstream<<"--worldname takes precedence over previously "
<<"selected world."<<std::endl;
}
commanded_world = worldspecs[i].path;
found = true;
break;
}
}
if(!found){
dstream<<"World '"<<commanded_worldname<<"' not "
<<"available. Available worlds:"<<std::endl;
print_worldspecs(worldspecs, dstream);
return 1;
}
}
// Gamespec
SubgameSpec commanded_gamespec;
if(cmd_args.exists("gameid")){
std::string gameid = cmd_args.get("gameid");
commanded_gamespec = findSubgame(gameid);
if(!commanded_gamespec.isValid()){
errorstream<<"Game \""<<gameid<<"\" not found"<<std::endl;
return 1;
}
}
/*
Run dedicated server if asked to or no other option
*/
#ifdef SERVER
bool run_dedicated_server = true;
#else
bool run_dedicated_server = cmd_args.getFlag("server");
#endif
if(run_dedicated_server)
{
DSTACK("Dedicated server branch");
// Create time getter if built with Irrlicht
#ifndef SERVER
g_timegetter = new SimpleTimeGetter();
#endif
// World directory
std::string world_path;
verbosestream<<"Determining world path"<<std::endl;
bool is_legacy_world = false;
// If a world was commanded, use it
if(commanded_world != ""){
world_path = commanded_world;
infostream<<"Using commanded world path ["<<world_path<<"]"
<<std::endl;
}
// No world was specified; try to select it automatically
else
{
// Get information about available worlds
std::vector<WorldSpec> worldspecs = getAvailableWorlds();
// If a world name was specified, select it
if(commanded_worldname != ""){
world_path = "";
for(u32 i=0; i<worldspecs.size(); i++){
std::string name = worldspecs[i].name;
if(name == commanded_worldname){
world_path = worldspecs[i].path;
break;
}
}
if(world_path == ""){
dstream<<"World '"<<commanded_worldname<<"' not "
<<"available. Available worlds:"<<std::endl;
print_worldspecs(worldspecs, dstream);
return 1;
}
}
// If there is only a single world, use it
if(worldspecs.size() == 1){
world_path = worldspecs[0].path;
dstream<<"Automatically selecting world at ["
<<world_path<<"]"<<std::endl;
// If there are multiple worlds, list them
} else if(worldspecs.size() > 1){
dstream<<"Multiple worlds are available."<<std::endl;
dstream<<"Please select one using --worldname <name>"
<<" or --world <path>"<<std::endl;
print_worldspecs(worldspecs, dstream);
return 1;
// If there are no worlds, automatically create a new one
} else {
// This is the ultimate default world path
world_path = porting::path_user + DIR_DELIM + "worlds" +
DIR_DELIM + "world";
infostream<<"Creating default world at ["
<<world_path<<"]"<<std::endl;
}
}
if(world_path == ""){
errorstream<<"No world path specified or found."<<std::endl;
return 1;
}
verbosestream<<"Using world path ["<<world_path<<"]"<<std::endl;
// We need a gamespec.
SubgameSpec gamespec;
verbosestream<<"Determining gameid/gamespec"<<std::endl;
// If world doesn't exist
if(!getWorldExists(world_path))
{
// Try to take gamespec from command line
if(commanded_gamespec.isValid()){
gamespec = commanded_gamespec;
infostream<<"Using commanded gameid ["<<gamespec.id<<"]"<<std::endl;
}
// Otherwise we will be using "minetest"
else{
gamespec = findSubgame(g_settings->get("default_game"));
infostream<<"Using default gameid ["<<gamespec.id<<"]"<<std::endl;
}
}
// World exists
else
{
std::string world_gameid = getWorldGameId(world_path, is_legacy_world);
// If commanded to use a gameid, do so
if(commanded_gamespec.isValid()){
gamespec = commanded_gamespec;
if(commanded_gamespec.id != world_gameid){
errorstream<<"WARNING: Using commanded gameid ["
<<gamespec.id<<"]"<<" instead of world gameid ["
<<world_gameid<<"]"<<std::endl;
}
} else{
// If world contains an embedded game, use it;
// Otherwise find world from local system.
gamespec = findWorldSubgame(world_path);
infostream<<"Using world gameid ["<<gamespec.id<<"]"<<std::endl;
}
}
if(!gamespec.isValid()){
errorstream<<"Subgame ["<<gamespec.id<<"] could not be found."
<<std::endl;
return 1;
}
verbosestream<<"Using gameid ["<<gamespec.id<<"]"<<std::endl;
// Create server
Server server(world_path, configpath, gamespec, false);
server.start(port);
// Run server
dedicated_server_loop(server, kill);
return 0;
}
#ifndef SERVER // Exclude from dedicated server build
/*
More parameters
*/
std::string address = g_settings->get("address");
if(commanded_world != "")
address = "";
else if(cmd_args.exists("address"))
address = cmd_args.get("address");
std::string playername = g_settings->get("name");
if(cmd_args.exists("name"))
playername = cmd_args.get("name");
bool skip_main_menu = cmd_args.getFlag("go");
/*
Device initialization
*/
// Resolution selection
bool fullscreen = g_settings->getBool("fullscreen");
u16 screenW = g_settings->getU16("screenW");
u16 screenH = g_settings->getU16("screenH");
// bpp, fsaa, vsync
bool vsync = g_settings->getBool("vsync");
u16 bits = g_settings->getU16("fullscreen_bpp");
u16 fsaa = g_settings->getU16("fsaa");
// Determine driver
video::E_DRIVER_TYPE driverType;
std::string driverstring = g_settings->get("video_driver");
if(driverstring == "null")
driverType = video::EDT_NULL;
else if(driverstring == "software")
driverType = video::EDT_SOFTWARE;
else if(driverstring == "burningsvideo")
driverType = video::EDT_BURNINGSVIDEO;
else if(driverstring == "direct3d8")
driverType = video::EDT_DIRECT3D8;
else if(driverstring == "direct3d9")
driverType = video::EDT_DIRECT3D9;
else if(driverstring == "opengl")
driverType = video::EDT_OPENGL;
else
{
errorstream<<"WARNING: Invalid video_driver specified; defaulting "
"to opengl"<<std::endl;
driverType = video::EDT_OPENGL;
}
/*
Create device and exit if creation failed
*/
MyEventReceiver receiver;
IrrlichtDevice *device;
SIrrlichtCreationParameters params = SIrrlichtCreationParameters();
params.DriverType = driverType;
params.WindowSize = core::dimension2d<u32>(screenW, screenH);
params.Bits = bits;
params.AntiAlias = fsaa;
params.Fullscreen = fullscreen;
params.Stencilbuffer = false;
params.Vsync = vsync;
params.EventReceiver = &receiver;
device = createDeviceEx(params);
if (device == 0)
return 1; // could not create selected driver.
/*
Continue initialization
*/
video::IVideoDriver* driver = device->getVideoDriver();
// Disable mipmaps (because some of them look ugly)
driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, false);
/*
This changes the minimum allowed number of vertices in a VBO.
Default is 500.
*/
//driver->setMinHardwareBufferVertexCount(50);
// Create time getter
g_timegetter = new IrrlichtTimeGetter(device);
// Create game callback for menus
g_gamecallback = new MainGameCallback(device);
/*
Speed tests (done after irrlicht is loaded to get timer)
*/
if(cmd_args.getFlag("speedtests"))
{
dstream<<"Running speed tests"<<std::endl;
SpeedTests();
return 0;
}
device->setResizable(true);
bool random_input = g_settings->getBool("random_input")
|| cmd_args.getFlag("random-input");
InputHandler *input = NULL;
if(random_input)
input = new RandomInputHandler();
else
input = new RealInputHandler(device, &receiver);
scene::ISceneManager* smgr = device->getSceneManager();
guienv = device->getGUIEnvironment();
gui::IGUISkin* skin = guienv->getSkin();
gui::IGUIFont* font = guienv->getFont(getTexturePath("fontlucida.png").c_str());
if(font)
skin->setFont(font);
else
errorstream<<"WARNING: Font file was not found."
" Using default font."<<std::endl;
// If font was not found, this will get us one
font = skin->getFont();
assert(font);
u32 text_height = font->getDimension(L"Hello, world!").Height;
infostream<<"text_height="<<text_height<<std::endl;
//skin->setColor(gui::EGDC_BUTTON_TEXT, video::SColor(255,0,0,0));
skin->setColor(gui::EGDC_BUTTON_TEXT, video::SColor(255,255,255,255));
//skin->setColor(gui::EGDC_3D_HIGH_LIGHT, video::SColor(0,0,0,0));
//skin->setColor(gui::EGDC_3D_SHADOW, video::SColor(0,0,0,0));
skin->setColor(gui::EGDC_3D_HIGH_LIGHT, video::SColor(255,0,0,0));
skin->setColor(gui::EGDC_3D_SHADOW, video::SColor(255,0,0,0));
skin->setColor(gui::EGDC_HIGH_LIGHT, video::SColor(255,70,100,50));
skin->setColor(gui::EGDC_HIGH_LIGHT_TEXT, video::SColor(255,255,255,255));
/*
GUI stuff
*/
ChatBackend chat_backend;
/*
If an error occurs, this is set to something and the
menu-game loop is restarted. It is then displayed before
the menu.
*/
std::wstring error_message = L"";
// The password entered during the menu screen,
std::string password;
bool first_loop = true;
/*
Menu-game loop
*/
while(device->run() && kill == false)
{
// Set the window caption
device->setWindowCaption(L"Minetest [Main Menu]");
// This is used for catching disconnects
try
{
/*
Clear everything from the GUIEnvironment
*/
guienv->clear();
/*
We need some kind of a root node to be able to add
custom gui elements directly on the screen.
Otherwise they won't be automatically drawn.
*/
guiroot = guienv->addStaticText(L"",
core::rect<s32>(0, 0, 10000, 10000));
SubgameSpec gamespec;
WorldSpec worldspec;
bool simple_singleplayer_mode = false;
// These are set up based on the menu and other things
std::string current_playername = "inv£lid";
std::string current_password = "";
std::string current_address = "does-not-exist";
int current_port = 0;
/*
Out-of-game menu loop.
Loop quits when menu returns proper parameters.
*/
while(kill == false)
{
// If skip_main_menu, only go through here once
if(skip_main_menu && !first_loop){
kill = true;
break;
}
first_loop = false;
// Cursor can be non-visible when coming from the game
device->getCursorControl()->setVisible(true);
// Some stuff are left to scene manager when coming from the game
// (map at least?)
smgr->clear();
// Initialize menu data
MainMenuData menudata;
if(g_settings->exists("selected_mainmenu_tab"))
menudata.selected_tab = g_settings->getS32("selected_mainmenu_tab");
menudata.address = narrow_to_wide(address);
menudata.name = narrow_to_wide(playername);
menudata.port = narrow_to_wide(itos(port));
if(cmd_args.exists("password"))
menudata.password = narrow_to_wide(cmd_args.get("password"));
menudata.fancy_trees = g_settings->getBool("new_style_leaves");
menudata.smooth_lighting = g_settings->getBool("smooth_lighting");
menudata.clouds_3d = g_settings->getBool("enable_3d_clouds");
menudata.opaque_water = g_settings->getBool("opaque_water");
menudata.creative_mode = g_settings->getBool("creative_mode");
menudata.enable_damage = g_settings->getBool("enable_damage");
// Default to selecting nothing
menudata.selected_world = -1;
// Get world listing for the menu
std::vector<WorldSpec> worldspecs = getAvailableWorlds();
// If there is only one world, select it
if(worldspecs.size() == 1){
menudata.selected_world = 0;
}
// Otherwise try to select according to selected_world_path
else if(g_settings->exists("selected_world_path")){
std::string trypath = g_settings->get("selected_world_path");
for(u32 i=0; i<worldspecs.size(); i++){
if(worldspecs[i].path == trypath){
menudata.selected_world = i;
break;
}
}
}
// If a world was commanded, append and select it
if(commanded_world != ""){
std::string gameid = getWorldGameId(commanded_world, true);
std::string name = "[--world parameter]";
if(gameid == ""){
gameid = g_settings->get("default_game");
name += " [new]";
}
WorldSpec spec(commanded_world, name, gameid);
worldspecs.push_back(spec);
menudata.selected_world = worldspecs.size()-1;
}
// Copy worldspecs to menu
menudata.worlds = worldspecs;
if(skip_main_menu == false)
{
video::IVideoDriver* driver = device->getVideoDriver();
infostream<<"Waiting for other menus"<<std::endl;
while(device->run() && kill == false)
{
if(noMenuActive())
break;
driver->beginScene(true, true,
video::SColor(255,128,128,128));
drawMenuBackground(driver);
guienv->drawAll();
driver->endScene();
// On some computers framerate doesn't seem to be
// automatically limited
sleep_ms(25);
}
infostream<<"Waited for other menus"<<std::endl;
GUIMainMenu *menu =
new GUIMainMenu(guienv, guiroot, -1,
&g_menumgr, &menudata, g_gamecallback);
menu->allowFocusRemoval(true);
if(error_message != L"")
{
verbosestream<<"error_message = "
<<wide_to_narrow(error_message)<<std::endl;
GUIMessageMenu *menu2 =
new GUIMessageMenu(guienv, guiroot, -1,
&g_menumgr, error_message.c_str());
menu2->drop();
error_message = L"";
}
infostream<<"Created main menu"<<std::endl;
while(device->run() && kill == false)
{
if(menu->getStatus() == true)
break;
//driver->beginScene(true, true, video::SColor(255,0,0,0));
driver->beginScene(true, true, video::SColor(255,128,128,128));
drawMenuBackground(driver);
guienv->drawAll();
driver->endScene();
// On some computers framerate doesn't seem to be
// automatically limited
sleep_ms(25);
}
infostream<<"Dropping main menu"<<std::endl;
menu->drop();
}
playername = wide_to_narrow(menudata.name);
password = translatePassword(playername, menudata.password);
//infostream<<"Main: password hash: '"<<password<<"'"<<std::endl;
address = wide_to_narrow(menudata.address);
int newport = stoi(wide_to_narrow(menudata.port));
if(newport != 0)
port = newport;
simple_singleplayer_mode = menudata.simple_singleplayer_mode;
// Save settings
g_settings->setS32("selected_mainmenu_tab", menudata.selected_tab);
g_settings->set("new_style_leaves", itos(menudata.fancy_trees));
g_settings->set("smooth_lighting", itos(menudata.smooth_lighting));
g_settings->set("enable_3d_clouds", itos(menudata.clouds_3d));
g_settings->set("opaque_water", itos(menudata.opaque_water));
g_settings->set("creative_mode", itos(menudata.creative_mode));
g_settings->set("enable_damage", itos(menudata.enable_damage));
g_settings->set("name", playername);
g_settings->set("address", address);
g_settings->set("port", itos(port));
if(menudata.selected_world != -1)
g_settings->set("selected_world_path",
worldspecs[menudata.selected_world].path);
// Break out of menu-game loop to shut down cleanly
if(device->run() == false || kill == true)
break;
current_playername = playername;
current_password = password;
current_address = address;
current_port = port;
// If using simple singleplayer mode, override
if(simple_singleplayer_mode){
current_playername = "singleplayer";
current_password = "";
current_address = "";
current_port = 30011;
}
// Set world path to selected one
if(menudata.selected_world != -1){
worldspec = worldspecs[menudata.selected_world];
infostream<<"Selected world: "<<worldspec.name
<<" ["<<worldspec.path<<"]"<<std::endl;
}
// Only refresh if so requested
if(menudata.only_refresh){
infostream<<"Refreshing menu"<<std::endl;
continue;
}
// Create new world if requested
if(menudata.create_world_name != L"")
{
std::string path = porting::path_user + DIR_DELIM
"worlds" + DIR_DELIM
+ wide_to_narrow(menudata.create_world_name);
// Create world if it doesn't exist
if(!initializeWorld(path, menudata.create_world_gameid)){
error_message = L"Failed to initialize world";
errorstream<<wide_to_narrow(error_message)<<std::endl;
continue;
}
g_settings->set("selected_world_path", path);
continue;
}
// If local game
if(current_address == "")
{
if(menudata.selected_world == -1){
error_message = L"No world selected and no address "
L"provided. Nothing to do.";
errorstream<<wide_to_narrow(error_message)<<std::endl;
continue;
}
// Load gamespec for required game
gamespec = findWorldSubgame(worldspec.path);
if(!gamespec.isValid() && !commanded_gamespec.isValid()){
error_message = L"Could not find or load game \""
+ narrow_to_wide(worldspec.gameid) + L"\"";
errorstream<<wide_to_narrow(error_message)<<std::endl;
continue;
}
if(commanded_gamespec.isValid() &&
commanded_gamespec.id != worldspec.gameid){
errorstream<<"WARNING: Overriding gamespec from \""
<<worldspec.gameid<<"\" to \""
<<commanded_gamespec.id<<"\""<<std::endl;
gamespec = commanded_gamespec;
}
if(!gamespec.isValid()){
error_message = L"Invalid gamespec. (world_gameid="
+narrow_to_wide(worldspec.gameid)+L")";
errorstream<<wide_to_narrow(error_message)<<std::endl;
continue;
}
}
// Continue to game
break;
}
// Break out of menu-game loop to shut down cleanly
if(device->run() == false || kill == true)
break;
/*
Run game
*/
the_game(
kill,
random_input,
input,
device,
font,
worldspec.path,
current_playername,
current_password,
current_address,
current_port,
error_message,
configpath,
chat_backend,
gamespec,
simple_singleplayer_mode
);
} //try
catch(con::PeerNotFoundException &e)
{
error_message = L"Connection error (timed out?)";
errorstream<<wide_to_narrow(error_message)<<std::endl;
}
catch(ServerError &e)
{
error_message = narrow_to_wide(e.what());
errorstream<<wide_to_narrow(error_message)<<std::endl;
}
catch(ModError &e)
{
errorstream<<e.what()<<std::endl;
error_message = narrow_to_wide(e.what()) + L"\nCheck debug.txt for details.";
}
#ifdef NDEBUG
catch(std::exception &e)
{
std::string narrow_message = "Some exception, what()=\"";
narrow_message += e.what();
narrow_message += "\"";
errorstream<<narrow_message<<std::endl;
error_message = narrow_to_wide(narrow_message);
}
#endif
// If no main menu, show error and exit
if(skip_main_menu)
{
if(error_message != L""){
verbosestream<<"error_message = "
<<wide_to_narrow(error_message)<<std::endl;
retval = 1;
}
break;
}
} // Menu-game loop
delete input;
/*
In the end, delete the Irrlicht device.
*/
device->drop();
#endif // !SERVER
// Update configuration file
if(configpath != "")
g_settings->updateConfigFile(configpath.c_str());
// Print modified quicktune values
{
bool header_printed = false;
std::vector<std::string> names = getQuicktuneNames();
for(u32 i=0; i<names.size(); i++){
QuicktuneValue val = getQuicktuneValue(names[i]);
if(!val.modified)
continue;
if(!header_printed){
dstream<<"Modified quicktune values:"<<std::endl;
header_printed = true;
}
dstream<<names[i]<<" = "<<val.getString()<<std::endl;
}
}
END_DEBUG_EXCEPTION_HANDLER(errorstream)
debugstreams_deinit();
return retval;
}
int main(int argc, char *argv[])
{
struct sockaddr_in me;
#ifdef ENABLE_IPV6
struct sockaddr_in6 me6;
#endif /* ENABLE_IPV6 */
curl_socket_t sock, msgsock;
int flag;
unsigned short port = DEFAULT_PORT;
char *pidname= (char *)".http.pid";
struct httprequest req;
int rc;
int arg=1;
#ifdef CURL_SWS_FORK_ENABLED
bool use_fork = FALSE;
#endif
while(argc>arg) {
if(!strcmp("--version", argv[arg])) {
printf("sws IPv4%s"
#ifdef CURL_SWS_FORK_ENABLED
" FORK"
#endif
"\n"
,
#ifdef ENABLE_IPV6
"/IPv6"
#else
""
#endif
);
return 0;
}
else if(!strcmp("--pidfile", argv[arg])) {
arg++;
if(argc>arg)
pidname = argv[arg++];
}
else if(!strcmp("--ipv6", argv[arg])) {
#ifdef ENABLE_IPV6
ipv_inuse = "IPv6";
use_ipv6 = TRUE;
#endif
arg++;
}
#ifdef CURL_SWS_FORK_ENABLED
else if(!strcmp("--fork", argv[arg])) {
use_fork=TRUE;
arg++;
}
#endif
else if(argc>arg) {
if(atoi(argv[arg]))
port = (unsigned short)atoi(argv[arg++]);
if(argc>arg)
path = argv[arg++];
}
}
#ifdef WIN32
win32_init();
atexit(win32_cleanup);
#else
#ifdef SIGPIPE
#ifdef HAVE_SIGNAL
signal(SIGPIPE, sigpipe_handler);
#endif
#ifdef HAVE_SIGINTERRUPT
siginterrupt(SIGPIPE, 1);
#endif
#endif
#endif
#ifdef ENABLE_IPV6
if(!use_ipv6)
#endif
sock = socket(AF_INET, SOCK_STREAM, 0);
#ifdef ENABLE_IPV6
else
sock = socket(AF_INET6, SOCK_STREAM, 0);
#endif
if (CURL_SOCKET_BAD == sock) {
logmsg("Error opening socket: %d", SOCKERRNO);
return 1;
}
flag = 1;
if (0 != setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
(void *) &flag, sizeof(flag))) {
logmsg("setsockopt(SO_REUSEADDR) failed: %d", SOCKERRNO);
sclose(sock);
return 1;
}
#ifdef ENABLE_IPV6
if(!use_ipv6) {
#endif
memset(&me, 0, sizeof(me));
me.sin_family = AF_INET;
me.sin_addr.s_addr = INADDR_ANY;
me.sin_port = htons(port);
rc = bind(sock, (struct sockaddr *) &me, sizeof(me));
#ifdef ENABLE_IPV6
}
else {
memset(&me6, 0, sizeof(me6));
me6.sin6_family = AF_INET6;
me6.sin6_addr = in6addr_any;
me6.sin6_port = htons(port);
rc = bind(sock, (struct sockaddr *) &me6, sizeof(me6));
}
#endif /* ENABLE_IPV6 */
if(0 != rc) {
logmsg("Error binding socket: %d", SOCKERRNO);
sclose(sock);
return 1;
}
if(!write_pidfile(pidname)) {
sclose(sock);
return 1;
}
logmsg("Running %s version on port %d", ipv_inuse, (int)port);
/* start accepting connections */
rc = listen(sock, 5);
if(0 != rc) {
logmsg("listen() failed with error: %d", SOCKERRNO);
sclose(sock);
return 1;
}
while (1) {
msgsock = accept(sock, NULL, NULL);
if (CURL_SOCKET_BAD == msgsock) {
printf("MAJOR ERROR: accept() failed with error: %d\n", SOCKERRNO);
break;
}
set_advisor_read_lock(SERVERLOGS_LOCK);
#ifdef CURL_SWS_FORK_ENABLED
if(use_fork) {
/* The fork enabled version just forks off the child and don't care
about it anymore, so don't assume otherwise. Beware and don't do
this at home. */
rc = fork();
if(-1 == rc) {
printf("MAJOR ERROR: fork() failed!\n");
break;
}
}
else
/* not a fork, just set rc so the following proceeds nicely */
rc = 0;
/* 0 is returned to the child */
if(0 == rc) {
#endif
logmsg("====> Client connect");
#ifdef TCP_NODELAY
/*
* Disable the Nagle algorithm to make it easier to send out a large
* response in many small segments to torture the clients more.
*/
flag = 1;
if (setsockopt(msgsock, IPPROTO_TCP, TCP_NODELAY,
(void *)&flag, sizeof(flag)) == -1) {
logmsg("====> TCP_NODELAY failed");
}
#endif
/* initialization of httprequest struct is done in get_request(), but due
to pipelining treatment the pipelining struct field must be initialized
previously to FALSE every time a new connection arrives. */
req.pipelining = FALSE;
do {
if(get_request(msgsock, &req))
/* non-zero means error, break out of loop */
break;
if(prevbounce) {
/* bounce treatment requested */
if((req.testno == prevtestno) &&
(req.partno == prevpartno)) {
req.partno++;
logmsg("BOUNCE part number to %ld", req.partno);
}
else {
prevbounce = FALSE;
prevtestno = -1;
prevpartno = -1;
}
}
send_doc(msgsock, &req);
if((req.testno < 0) && (req.testno != DOCNUMBER_CONNECT)) {
logmsg("special request received, no persistency");
break;
}
if(!req.open) {
logmsg("instructed to close connection after server-reply");
break;
}
if(req.open)
logmsg("=> persistant connection request ended, awaits new request");
/* if we got a CONNECT, loop and get another request as well! */
} while(req.open || (req.testno == DOCNUMBER_CONNECT));
logmsg("====> Client disconnect");
sclose(msgsock);
clear_advisor_read_lock(SERVERLOGS_LOCK);
if (req.testno == DOCNUMBER_QUIT)
break;
#ifdef CURL_SWS_FORK_ENABLED
}
#endif
}
sclose(sock);
clear_advisor_read_lock(SERVERLOGS_LOCK);
return 0;
}
int
main(int argc, char **argv)
{
struct wipe_desc *wp0 = NULL, *wp;
int c, all = 0, force = 0, has_offset = 0, noact = 0, quiet = 0;
int mode = WP_MODE_PRETTY;
static const struct option longopts[] = {
{ "all", 0, 0, 'a' },
{ "force", 0, 0, 'f' },
{ "help", 0, 0, 'h' },
{ "no-act", 0, 0, 'n' },
{ "offset", 1, 0, 'o' },
{ "parsable", 0, 0, 'p' },
{ "quiet", 0, 0, 'q' },
{ "types", 1, 0, 't' },
{ "version", 0, 0, 'V' },
{ NULL, 0, 0, 0 }
};
static const ul_excl_t excl[] = { /* rows and cols in in ASCII order */
{ 'a','o' },
{ 0 }
};
int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
atexit(close_stdout);
while ((c = getopt_long(argc, argv, "ahno:pqt:V", longopts, NULL)) != -1) {
err_exclusive_options(c, longopts, excl, excl_st);
switch(c) {
case 'a':
all++;
break;
case 'f':
force++;
break;
case 'h':
usage(stdout);
break;
case 'n':
noact++;
break;
case 'o':
wp0 = add_offset(wp0, strtosize_or_err(optarg,
_("invalid offset argument")), 1);
has_offset++;
break;
case 'p':
mode = WP_MODE_PARSABLE;
break;
case 'q':
quiet++;
break;
case 't':
type_pattern = optarg;
break;
case 'V':
printf(UTIL_LINUX_VERSION);
return EXIT_SUCCESS;
default:
usage(stderr);
break;
}
}
if (optind == argc)
usage(stderr);
if (!all && !has_offset) {
/*
* Print only
*/
while (optind < argc) {
wp0 = read_offsets(NULL, argv[optind++]);
if (wp0)
print_all(wp0, mode);
free_wipe(wp0);
}
} else {
/*
* Erase
*/
while (optind < argc) {
wp = clone_offset(wp0);
wp = do_wipe(wp, argv[optind++], noact, all, quiet,
force);
free_wipe(wp);
}
}
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
int get_tmp = 1, get_cmd;
int dhinfo_ret;
if(argc < 3) {
print_help(argv[0]);
exit(2);
}
init_rand();
atexit(cleanup);
signal(SIGSEGV, sigcleanup);
signal(SIGABRT, sigcleanup);
signal(SIGTERM, sigcleanup);
signal(SIGINT, sigcleanup);
signal(SIGHUP, sigcleanup);
int option_index = 0;
static struct option long_options[] = {
{ "mac", required_argument, 0, 'm' },
{ "random-mac", no_argument, 0, 'R' },
{ "log-filename", required_argument, 0, 'F' },
{ "interface", required_argument, 0, 'i' },
{ "vlan", required_argument, 0, 'v' },
{ "dhcp_xid", required_argument, 0, 'x' },
{ "tos", required_argument, 0, 't' },
{ "option51-lease_time", required_argument, 0, 'L' },
{ "option50-ip", required_argument, 0, 'I' },
{ "option60-vci", required_argument, 0, 'o' },
{ "option12-hostname", required_argument, 0, 'h' },
{ "timeout", required_argument, 0, 'T' },
{ "bind-ip", no_argument, 0, 'b' },
{ "bind-timeout", required_argument, 0, 'k' },
{ "bcast_flag", no_argument, 0, 'f'},
{ "verbose", no_argument, 0, 'V'},
{ "fqdn-server-not-update", no_argument, 0, 'n'},
{ "fqdn-server-update-a", no_argument, 0, 's'},
{ "fqdn-domain-name", required_argument, 0, 'd'},
{ "padding", no_argument, 0, 'p'},
{ "port", required_argument, 0, 'P'},
{ "giaddr", required_argument, 0, 'g'},
{ "unicast", optional_argument, 0, 'u'},
{ "nagios", no_argument, 0, 'a'},
{ "server", required_argument, 0, 'S'},
{ "release", no_argument, 0, 'r'},
{ "quiet", no_argument, 0, 'q'},
{ "request-only", no_argument, 0, 'Q'},
{ 0, 0, 0, 0 }
};
/*getopt routine to get command line arguments*/
while(get_tmp < argc) {
get_cmd = getopt_long(argc, argv, "m:Ri:v:t:bfVrpansu::T:P:g:S:I:o:k:L:h:d:F:qQ",\
long_options, &option_index);
if(get_cmd == -1 ) {
break;
}
switch(get_cmd) {
case 'q':
quiet = 1;
break;
case 'm':
{
u_char aux_dhmac[ETHER_ADDR_LEN + 1];
if(strlen(optarg) != 17
|| sscanf(optarg, ETH_F_FMT, ETH_F_PARG(aux_dhmac)) != 6
)
{
fprintf(stderr, "Invalid mac address\n");
exit(2);
}
memcpy(dhmac, aux_dhmac, sizeof(dhmac));
dhmac_flag = 1;
}
break;
case 'R':
{
int i;
for (i = 0; i < ETHER_ADDR_LEN; i++)
dhmac[i] = rand() & 0xff;
/* clear multicast bit, set the L bit, clear MSB */
dhmac[0] &= ~0x81;
dhmac[0] |= 0x02;
dhmac_flag = 1;
}
break;
case 'F':
if (strlen(optarg) > sizeof(dhmac_fname) - 1) {
fprintf(stderr, "-F filename given is too long\n");
exit(2);
}
strcpy(dhmac_fname, optarg);
dhmac_fname_flag = 1;
break;
case 'i':
iface_name = optarg;
break;
case 'v':
if(atoi(optarg) < 1 || atoi(optarg) > 4095)
{
fprintf(stderr, "VLAN ID is not valid. Range 1 to 4095\n");
exit(2);
}
vlan = atoi(optarg);
l2_hdr_size = 18;
break;
case 'r':
dhcp_release_flag = 1;
break;
case 'Q':
dhcp_request_flag = 1;
break;
case 'b':
ip_listen_flag = 1;
break;
case 'k':
listen_timeout = atoi(optarg);
tval_listen.tv_sec = listen_timeout;
break;
case 'x':
{
u_int32_t aux_dhcp_xid[2];
aux_dhcp_xid[0] = 0;
sscanf((char *)optarg, "%X", &aux_dhcp_xid[0]);
dhcp_xid = aux_dhcp_xid[0];
}
break;
case 't':
if(atoi(optarg) >= 256 || atoi(optarg) < 0) {
fprintf(stderr, "Invalid TOS value\n");
exit(2);
}
l3_tos = atoi(optarg);
break;
case 'L':
option51_lease_time = atoi(optarg);
break;
case 'I':
option50_ip = inet_addr(optarg);
break;
case 'o':
if(strlen(optarg) >= 256) {
fprintf(stderr, "VCI string size should be less than 256\n");
exit(2);
}
vci_flag = 1;
vci_buff = optarg;
break;
case 'h':
if(strlen(optarg) >= 256) {
fprintf(stderr, "Hostname string size should be less than 256\n");
exit(2);
}
hostname_flag = 1;
hostname_buff = optarg;
break;
case 'd':
if(strlen(optarg) >= 253) {
fprintf(stderr, "FQDN domain name string size should be less than 253\n");
exit(2);
}
fqdn_flag = 1;
fqdn_buff = optarg;
break;
case 'n':
fqdn_n = 1;
break;
case 's':
fqdn_s = 1;
break;
case 'T':
if(atoi(optarg) < 5 || atoi(optarg) > 3600) {
fprintf(stderr, "Invalid timout value. Range 5 to 3600\n");
exit(2);
}
timeout = atoi(optarg);
break;
case 'P':
if(atoi(optarg) <=0 || atoi(optarg) > 65535) {
fprintf(stderr, "Invalid port value. Range 1 to 65535\n");
exit(2);
}
port = atoi(optarg);
break;
case 'g':
giaddr = optarg;
break;
case 'S':
server_addr = optarg;
break;
case 'p':
padding_flag = 1;
break;
case 'f':
bcast_flag = htons(0x8000);
break;
case 'V':
verbose = 1;
break;
case 'u':
if (optarg) {
struct in_addr out;
if (!inet_aton(optarg, &out)) {
fprintf(stderr, "Invalid unicast IP address.");
exit(2);
}
unicast_ip_address = out.s_addr;
}
unicast_flag = 1;
break;
case 'a':
nagios_flag = 1;
break;
default:
exit(2);
}
get_tmp++;
}
if(!dhmac_flag) {
print_help(argv[0]);
exit(2);
}
if (!dhmac_fname_flag)
sprintf(dhmac_fname, ETH_F_FMT, ETH_F_ARG(dhmac));
dhinfo_ret = get_dhinfo();
iface = if_nametoindex(iface_name);
if(iface == 0) {
fprintf(stderr, "Interface %s does not exist\n", iface_name);
exit(2);
}
/* Opens the PF_PACKET socket */
if(open_socket() < 0)
critical("Socket error: %m");
/* Sets the promiscuous mode */
set_promisc();
if (unicast_flag && !unicast_ip_address) {
unicast_ip_address = get_interface_address();
}
/* Sets a random DHCP xid */
set_rand_dhcp_xid();
time_now = time_last = time(NULL);
/*
* If DHCP release flag is set, send DHCP release packet
* and exit. get_dhinfo parses the DHCP info from log file
* and unlinks it from the system
*/
if(dhcp_release_flag) {
if(dhinfo_ret)
critical("Error on opening DHCP info file: %s", strerror(dhinfo_ret));
if (!server_id)
critical("Can't release IP without an active lease");
build_option53(DHCP_MSGRELEASE); /* Option53 DHCP release */
if(hostname_flag) {
build_option12_hostname();
}
if(fqdn_flag) {
build_option81_fqdn();
}
build_option54(); /* Server id */
build_optioneof(); /* End of option */
build_dhpacket(DHCP_MSGRELEASE); /* Build DHCP release packet */
send_packet(DHCP_MSGRELEASE); /* Send DHCP release packet */
/* update status file: we no longer have our IP address */
log_dhinfo();
return 0;
}
if (dhcp_request_flag) {
if(dhinfo_ret)
critical("Error on opening DHCP info file: %s", strerror(dhinfo_ret));
if (!server_id)
critical("Can't refresh IP without an active lease");
/* Clients begin to attempt to renew their leases once half the lease interval has expired. */
if (lease_expires_at - time_now > option51_lease_time / 2)
return 0;
goto request;
}
build_option53(DHCP_MSGDISCOVER); /* Option53 for DHCP discover */
if(hostname_flag) {
build_option12_hostname();
}
if(fqdn_flag) {
build_option81_fqdn();
}
if(option50_ip) {
build_option50(); /* Option50 - req. IP */
}
if(option51_lease_time) {
build_option51(); /* Option51 - DHCP lease time requested */
}
if(vci_flag == 1) {
build_option60_vci(); /* Option60 - VCI */
}
build_optioneof(); /* End of option */
build_dhpacket(DHCP_MSGDISCOVER); /* Build DHCP discover packet */
int dhcp_offer_state = 0;
while(dhcp_offer_state != DHCP_OFFR_RCVD) {
/* Sends DHCP discover packet */
send_packet(DHCP_MSGDISCOVER);
/*
* recv_packet functions returns when the specified
* packet is received
*/
dhcp_offer_state = recv_packet(DHCP_MSGOFFER);
if(timeout) {
time_now = time(NULL);
if((time_now - time_last) > timeout)
critical("Timeout reached: DISCOVER");
}
if(dhcp_offer_state == DHCP_OFFR_RCVD) {
if (!nagios_flag && !quiet)
printf("DHCP offer received\t - ");
set_serv_id_opt50();
if (!nagios_flag && !quiet)
printf("Offered IP : %s\n", get_ip_str(dhcph_g->dhcp_yip));
if(!nagios_flag && verbose) {
print_dhinfo(DHCP_MSGOFFER);
}
}
}
request:
/* Reset the dhopt buffer to build DHCP request options */
reset_dhopt_size();
build_option53(DHCP_MSGREQUEST);
build_option50();
build_option54();
if(hostname_flag) {
build_option12_hostname();
}
if(fqdn_flag) {
build_option81_fqdn();
}
if(vci_flag == 1) {
build_option60_vci();
}
if(option51_lease_time) {
build_option51(); /* Option51 - DHCP lease time requested */
}
build_option55();
build_optioneof();
build_dhpacket(DHCP_MSGREQUEST); /* Builds specified packet */
int dhcp_ack_state = 1;
while(dhcp_ack_state != DHCP_ACK_RCVD) {
send_packet(DHCP_MSGREQUEST);
dhcp_ack_state = recv_packet(DHCP_MSGACK);
if(timeout) {
time_now = time(NULL);
if((time_now - time_last) > timeout)
critical("Timeout reached: REQUEST");
}
if(dhcp_ack_state == DHCP_ACK_RCVD) {
if (nagios_flag) {
printf("OK: Acquired IP: %s", get_ip_str(dhcph_g->dhcp_yip));
} else if (!quiet) {
printf("DHCP ack received\t - ");
printf("Acquired IP: %s\n", get_ip_str(dhcph_g->dhcp_yip));
}
else {
/* quiet */
printf("%s\n", get_ip_str(dhcph_g->dhcp_yip));
}
/* Logs DHCP IP details to log file. This file is used for DHCP release */
log_dhinfo();
if(!nagios_flag && verbose) {
print_dhinfo(DHCP_MSGACK);
}
} else if (dhcp_ack_state == DHCP_NAK_RCVD) {
if (!nagios_flag && !quiet) {
printf("DHCP nack received\t - ");
printf("Client MAC : %02x:%02x:%02x:%02x:%02x:%02x\n", \
dhmac[0], dhmac[1], dhmac[2], dhmac[3], dhmac[4], dhmac[5]);
}
}
}
/* If IP listen flag is enabled, Listen on obtained for ARP, ICMP protocols */
if(!nagios_flag && ip_listen_flag) {
if (!quiet) {
printf("\nListening on %s for ARP and ICMP protocols\n", iface_name);
printf("IP address: %s, Listen timeout: %d seconds\n", get_ip_str(htonl(ip_address)), listen_timeout);
}
int arp_icmp_rcv_state = 0;
while(arp_icmp_rcv_state != LISTEN_TIMEOUT) {
arp_icmp_rcv_state = recv_packet(ARP_ICMP_RCV);
/* Send ARP reply if ARP request received */
if(arp_icmp_rcv_state == ARP_RCVD) {
/*if(verbose) {
printf("ARP request received\n");
printf("Sending ARP reply\n");
}*/
build_packet(ARP_SEND);
send_packet(ARP_SEND);
} else if(arp_icmp_rcv_state == ICMP_RCVD) {
/* Send ICMP reply if ICMP echo request received */
/*if(verbose) {
printf("ICMP request received\n");
printf("Sending ICMP reply\n");
}*/
build_packet(ICMP_SEND);
send_packet(ICMP_SEND);
}
}
printf("Listen timout reached\n");
}
return 0;
}
int main(int argc, char *argv[])
{
apr_status_t rc;
apr_pool_t *pool;
stomp_connection *connection;
setbuf(stdout, NULL);
rc = apr_initialize();
rc==APR_SUCCESS || die(-2, "Could not initialize", rc);
atexit(terminate);
rc = apr_pool_create(&pool, NULL);
rc==APR_SUCCESS || die(-2, "Could not allocate pool", rc);
fprintf(stdout, "Connecting......");
rc=stomp_connect( &connection, "localhost", 61613, pool);
rc==APR_SUCCESS || die(-2, "Could not connect", rc);
fprintf(stdout, "OK\n");
fprintf(stdout, "Sending connect message.");
{
stomp_frame frame;
frame.command = "CONNECT";
frame.headers = apr_hash_make(pool);
apr_hash_set(frame.headers, "login", APR_HASH_KEY_STRING, "hchirino");
apr_hash_set(frame.headers, "passcode", APR_HASH_KEY_STRING, "letmein");
frame.body = NULL;
frame.body_length = -1;
rc = stomp_write(connection, &frame, pool);
rc==APR_SUCCESS || die(-2, "Could not send frame", rc);
}
fprintf(stdout, "OK\n");
fprintf(stdout, "Reading Response.");
{
stomp_frame *frame;
rc = stomp_read(connection, &frame, pool);
rc==APR_SUCCESS || die(-2, "Could not read frame", rc);
fprintf(stdout, "Response: %s, %s\n", frame->command, frame->body);
}
fprintf(stdout, "OK\n");
fprintf(stdout, "Sending Subscribe.");
{
stomp_frame frame;
frame.command = "SUB";
frame.headers = apr_hash_make(pool);
apr_hash_set(frame.headers, "destination", APR_HASH_KEY_STRING, "/queue/FOO.BAR");
frame.body_length = -1;
frame.body = NULL;
rc = stomp_write(connection, &frame, pool);
rc==APR_SUCCESS || die(-2, "Could not send frame", rc);
}
fprintf(stdout, "OK\n");
fprintf(stdout, "Sending Message.");
{
stomp_frame frame;
frame.command = "SEND";
frame.headers = apr_hash_make(pool);
apr_hash_set(frame.headers, "destination", APR_HASH_KEY_STRING, "/queue/test");
frame.body_length = -1;
frame.body = "This is the message";
rc = stomp_write(connection, &frame, pool);
rc==APR_SUCCESS || die(-2, "Could not send frame", rc);
}
fprintf(stdout, "OK\n");
fprintf(stdout, "Reading Response.");
{
stomp_frame *frame;
rc = stomp_read(connection, &frame, pool);
rc==APR_SUCCESS || die(-2, "Could not read frame", rc);
fprintf(stdout, "Response: %s, %s\n", frame->command, frame->body);
}
fprintf(stdout, "OK\n");
fprintf(stdout, "Sending Disconnect.");
{
stomp_frame frame;
frame.command = "DISCONNECT";
frame.headers = NULL;
frame.body_length = -1;
frame.body = NULL;
rc = stomp_write(connection, &frame, pool);
rc==APR_SUCCESS || die(-2, "Could not send frame", rc);
}
fprintf(stdout, "OK\n");
fprintf(stdout, "Disconnecting...");
rc=stomp_disconnect(&connection);
rc==APR_SUCCESS || die(-2, "Could not disconnect", rc);
fprintf(stdout, "OK\n");
apr_pool_destroy(pool);
return 0;
}
/*
* ======== System_Module_startup ========
*/
Int System_Module_startup(Int stat)
{
atexit(System_rtsExit);
return (Startup_DONE);
}
int sed_main(int argc UNUSED_PARAM, char **argv)
{
unsigned opt;
llist_t *opt_e, *opt_f;
char *opt_i;
#if ENABLE_LONG_OPTS
static const char sed_longopts[] ALIGN1 =
/* name has_arg short */
"in-place\0" Optional_argument "i"
"regexp-extended\0" No_argument "r"
"quiet\0" No_argument "n"
"silent\0" No_argument "n"
"expression\0" Required_argument "e"
"file\0" Required_argument "f";
#endif
int status = EXIT_SUCCESS;
INIT_G();
/* destroy command strings on exit */
if (ENABLE_FEATURE_CLEAN_UP) atexit(sed_free_and_close_stuff);
/* Lie to autoconf when it starts asking stupid questions. */
if (argv[1] && strcmp(argv[1], "--version") == 0) {
puts("This is not GNU sed version 4.0");
return 0;
}
/* do normal option parsing */
opt_e = opt_f = NULL;
opt_i = NULL;
opt_complementary = "e::f::" /* can occur multiple times */
"nn"; /* count -n */
IF_LONG_OPTS(applet_long_options = sed_longopts);
/* -i must be first, to match OPT_in_place definition */
/* -E is a synonym of -r:
* GNU sed 4.2.1 mentions it in neither --help
* nor manpage, but does recognize it.
*/
opt = getopt32(argv, "i::rEne:f:", &opt_i, &opt_e, &opt_f,
&G.be_quiet); /* counter for -n */
//argc -= optind;
argv += optind;
if (opt & OPT_in_place) { // -i
atexit(cleanup_outname);
}
if (opt & (2|4))
G.regex_type |= REG_EXTENDED; // -r or -E
//if (opt & 8)
// G.be_quiet++; // -n (implemented with a counter instead)
while (opt_e) { // -e
add_cmd_block(llist_pop(&opt_e));
}
while (opt_f) { // -f
char *line;
FILE *cmdfile;
cmdfile = xfopen_for_read(llist_pop(&opt_f));
while ((line = xmalloc_fgetline(cmdfile)) != NULL) {
add_cmd(line);
free(line);
}
fclose(cmdfile);
}
/* if we didn't get a pattern from -e or -f, use argv[0] */
if (!(opt & 0x30)) {
if (!*argv)
bb_show_usage();
add_cmd_block(*argv++);
}
/* Flush any unfinished commands. */
add_cmd("");
/* By default, we write to stdout */
G.nonstdout = stdout;
/* argv[0..(argc-1)] should be names of file to process. If no
* files were specified or '-' was specified, take input from stdin.
* Otherwise, we process all the files specified. */
if (argv[0] == NULL) {
if (opt & OPT_in_place)
bb_error_msg_and_die(bb_msg_requires_arg, "-i");
add_input_file(stdin);
} else {
int i;
for (i = 0; argv[i]; i++) {
struct stat statbuf;
int nonstdoutfd;
FILE *file;
sed_cmd_t *sed_cmd;
if (LONE_DASH(argv[i]) && !(opt & OPT_in_place)) {
add_input_file(stdin);
process_files();
continue;
}
file = fopen_or_warn(argv[i], "r");
if (!file) {
status = EXIT_FAILURE;
continue;
}
add_input_file(file);
if (!(opt & OPT_in_place)) {
continue;
}
/* -i: process each FILE separately: */
G.outname = xasprintf("%sXXXXXX", argv[i]);
nonstdoutfd = xmkstemp(G.outname);
G.nonstdout = xfdopen_for_write(nonstdoutfd);
/* Set permissions/owner of output file */
fstat(fileno(file), &statbuf);
/* chmod'ing AFTER chown would preserve suid/sgid bits,
* but GNU sed 4.2.1 does not preserve them either */
fchmod(nonstdoutfd, statbuf.st_mode);
fchown(nonstdoutfd, statbuf.st_uid, statbuf.st_gid);
process_files();
fclose(G.nonstdout);
G.nonstdout = stdout;
if (opt_i) {
char *backupname = xasprintf("%s%s", argv[i], opt_i);
xrename(argv[i], backupname);
free(backupname);
}
/* else unlink(argv[i]); - rename below does this */
xrename(G.outname, argv[i]); //TODO: rollback backup on error?
free(G.outname);
G.outname = NULL;
/* Re-enable disabled range matches */
for (sed_cmd = G.sed_cmd_head; sed_cmd; sed_cmd = sed_cmd->next) {
sed_cmd->beg_line = sed_cmd->beg_line_orig;
}
}
/* Here, to handle "sed 'cmds' nonexistent_file" case we did:
* if (G.current_input_file >= G.input_file_count)
* return status;
* but it's not needed since process_files() works correctly
* in this case too. */
}
process_files();
return status;
}
int gr_init(void)
{
int org_gamma;
int retcode;
int mode = SM(320,200);
// Only do this function once!
if (gr_installed==1)
return 3;
#ifdef __DJGPP__
if (!__djgpp_nearptr_enable()) {
printf("nearptr enable=%x\n", __dpmi_error);
return 10;
}
#ifndef SAVEGR
gr_video_memory = (unsigned char *)(__djgpp_conventional_base + 0xa0000);
#else
gr_video_memory=(unsigned char *)-1;
#endif
pVideoMode = (volatile ubyte *)(__djgpp_conventional_base+0x449);
pNumColumns = (volatile ushort *)(__djgpp_conventional_base+0x44a);
pNumRows = (volatile ubyte *)(__djgpp_conventional_base+0x484);
pCharHeight = (volatile ushort *)(__djgpp_conventional_base+0x485);
pCursorPos = (volatile ushort *)(__djgpp_conventional_base+0x450);
pCursorType = (volatile ushort *)(__djgpp_conventional_base+0x460);
pTextMemory = (volatile ushort *)(__djgpp_conventional_base+0xb8000);
#endif
#ifndef __DJGPP__
if (gr_init_A0000())
return 10;
#endif
// Save the current text screen mode
if (gr_save_mode()==1)
return 2;
#ifndef NOGRAPH
// Save the current palette, and fade it out to black.
gr_palette_read( gr_pal_default );
gr_palette_faded_out = 0;
org_gamma = gr_palette_get_gamma();
gr_palette_set_gamma( 0 );
gr_palette_fade_out( gr_pal_default, 32, 0 );
gr_palette_clear();
gr_palette_set_gamma( org_gamma );
gr_sync_display();
gr_sync_display();
#endif
#ifdef __DJGPP__
#ifdef SAVEGR
__djgpp_nearptr_disable();
#endif
#endif
MALLOC( grd_curscreen,grs_screen,1 );
memset( grd_curscreen, 0, sizeof(grs_screen));
// Set the mode.
if ((retcode=gr_set_mode(mode)))
{
gr_restore_mode();
return retcode;
}
//JOHNgr_disable_default_palette_loading();
// Set all the screen, canvas, and bitmap variables that
// aren't set by the gr_set_mode call:
grd_curscreen->sc_canvas.cv_color = 0;
grd_curscreen->sc_canvas.cv_drawmode = 0;
grd_curscreen->sc_canvas.cv_font = NULL;
grd_curscreen->sc_canvas.cv_font_fg_color = 0;
grd_curscreen->sc_canvas.cv_font_bg_color = 0;
gr_set_current_canvas( &grd_curscreen->sc_canvas );
#if 0
if (!dpmi_allocate_selector( &gr_fade_table, 256*GR_FADE_LEVELS, &gr_fade_table_selector ))
Error( "Error allocating fade table selector!" );
if (!dpmi_allocate_selector( &gr_palette, 256*3, &gr_palette_selector ))
Error( "Error allocating palette selector!" );
#endif
// if (!dpmi_allocate_selector( &gr_inverse_table, 32*32*32, &gr_inverse_table_selector ))
// Error( "Error allocating inverse table selector!" );
// Set flags indicating that this is installed.
gr_installed = 1;
#ifdef __GNUC__
atexit((void (*)) gr_close);
#else
atexit(gr_close);
#endif
return 0;
}
// Main
int main(int argc, char *argv[])
{
glutInit( &argc, argv );
glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );
glutInitWindowSize( 800, 600 );
glutCreateWindow( "Font rendering advanced tweaking" );
glutCreateMenu( NULL );
#ifndef __APPLE__
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf( stderr, "Error: %s\n", glewGetErrorString(err) );
exit( EXIT_FAILURE );
}
fprintf( stderr, "Using GLEW %s\n", glewGetString(GLEW_VERSION) );
#endif
glutDisplayFunc( display );
glutReshapeFunc( reshape );
atexit( terminate );
TwInit( TW_OPENGL, NULL );
glutMouseFunc( (GLUTmousebuttonfun)TwEventMouseButtonGLUT );
glutMotionFunc( (GLUTmousemotionfun)TwEventMouseMotionGLUT );
glutPassiveMotionFunc( (GLUTmousemotionfun)TwEventMouseMotionGLUT );
glutKeyboardFunc( (GLUTkeyboardfun)TwEventKeyboardGLUT );
glutSpecialFunc( (GLUTspecialfun)TwEventSpecialGLUT );
TwGLUTModifiersFunc( glutGetModifiers );
// Create a new tweak bar
bar = TwNewBar("TweakBar");
TwDefine("GLOBAL "
"help = 'This example shows how to tune all font parameters.' ");
TwDefine("TweakBar "
"size = '280 400' "
"position = '500 20' "
"color = '127 127 127' "
"alpha = 240 "
"label = 'Parameters' "
"resizable = True "
"fontresizable = True "
"iconifiable = True ");
{
TwEnumVal familyEV[NUM_FONTS] = {
{VERA, "Vera"},
{VERA_MONO, "Vera Mono"},
{LUCKIEST_GUY, "Luckiest Guy"},
{SOURCE_SANS, "Source Sans Pro"},
{SOURCE_CODE, "Source Code Pro"},
{OLD_STANDARD, "Old Standard TT"},
{LOBSTER, "Lobster"} };
TwType family_type = TwDefineEnum("Family", familyEV, NUM_FONTS);
TwAddVarCB(bar, "Family", family_type, set_family, get_family, NULL,
"label = 'Family' "
"group = 'Font' "
"help = ' ' ");
}
TwAddVarCB(bar, "Size", TW_TYPE_FLOAT, set_size, get_size, NULL,
"label = 'Size' "
"group = 'Font' "
"min = 6.0 "
"max = 24.0 "
"step = 0.05 "
"help = ' ' ");
TwAddVarCB(bar, "LCD filtering", TW_TYPE_BOOL32, set_lcd_filtering, get_lcd_filtering, NULL,
"label = 'LCD filtering' "
"group = 'Font' "
"help = ' ' ");
// Rendering
TwAddVarCB(bar, "Kerning", TW_TYPE_BOOL32, set_kerning, get_kerning, NULL,
"label = 'Kerning' "
"group = 'Rendering' "
"help = ' ' ");
TwAddVarCB(bar, "Hinting", TW_TYPE_BOOL32, set_hinting, get_hinting, NULL,
"label = 'Hinting' "
"group = 'Rendering' "
"help = ' ' ");
// Color
TwAddVarCB(bar, "Invert", TW_TYPE_BOOL32, set_invert, get_invert, NULL,
"label = 'Invert' "
"group = 'Color' "
"help = ' ' ");
// Glyph
TwAddVarCB(bar, "Width", TW_TYPE_FLOAT, set_width, get_width, NULL,
"label = 'Width' "
"group = 'Glyph' "
"min = 0.75 "
"max = 1.25 "
"step = 0.01 "
"help = ' ' ");
TwAddVarCB(bar, "Interval", TW_TYPE_FLOAT, set_interval, get_interval, NULL,
"label = 'Spacing' "
"group = 'Glyph' "
"min = -0.2 "
"max = 0.2 "
"step = 0.01 "
"help = ' ' " );
TwAddVarCB(bar, "Faux italic", TW_TYPE_FLOAT, set_faux_italic, get_faux_italic, NULL,
"label = 'Faux italic' "
"group = 'Glyph' "
"min = -30.0 "
"max = 30.0 "
"step = 0.1 "
"help = ' ' ");
// Energy distribution
TwAddVarCB(bar, "Primary", TW_TYPE_FLOAT, set_primary, get_primary, NULL,
"label = 'Primary weight' "
"group = 'Energy distribution' "
"min = 0 "
"max = 1 "
"step = 0.01 "
"help = ' ' " );
TwAddVarCB(bar, "Secondary", TW_TYPE_FLOAT, set_secondary, get_secondary, NULL,
"label = 'Secondy weight' "
"group = 'Energy distribution' "
"min = 0 "
"max = 1 "
"step = 0.01 "
"help = ' ' " );
TwAddVarCB(bar, "Tertiary", TW_TYPE_FLOAT, set_tertiary, get_tertiary, NULL,
"label = 'Tertiary weight' "
"group = 'Energy distribution' "
"min = 0 "
"max = 1 "
"step = 0.01 "
"help = ' ' " );
TwAddSeparator(bar, "",
"group = 'Energy distribution' " );
TwAddVarCB(bar, "Gamma", TW_TYPE_FLOAT, set_gamma, get_gamma, NULL,
"label = 'Gamma correction' "
"group = 'Energy distribution' "
"min = 0.50 "
"max = 2.5 "
"step = 0.01 "
"help = ' ' ");
TwAddSeparator(bar, "", "");
TwAddButton(bar, "Reset", (TwButtonCallback) reset, NULL,
"help='Reset all parameters to default values.'");
TwAddSeparator(bar, "", "");
TwAddButton(bar, "Quit", (TwButtonCallback) quit, NULL,
"help='Quit.'");
buffer_a = text_buffer_new( 1 );
buffer_rgb = text_buffer_new( 3 );
buffer = buffer_rgb;
reset();
glutTimerFunc( 1000.0/60.0, timer, 60 );
mat4_set_identity( &projection );
mat4_set_identity( &model );
mat4_set_identity( &view );
glutMainLoop();
return EXIT_SUCCESS;
}
void initialize(void) {
apr_initialize();
atexit(apr_terminate);
apr_pool_create(&p, NULL);
}
int main(int argc, char* argv[] )
{
atexit( closeFiles );
// Copy to char pointers
char outputChanChar[1024];
strcpy(outputChanChar, PERCEPTION_CHANNEL.c_str());
char debugChanChar[1024];
strcpy(debugChanChar, DEBUG_CHANNEL.c_str());
// open the channels
int r = ach_open( &channel, outputChanChar, NULL );
int rdebug = ach_open( &debug_channel, debugChanChar, NULL );
assert(ACH_OK == r && ACH_OK == rdebug);
r = ach_flush(&channel);
r = ach_flush(&debug_channel);
// test receive
double percep[NUM_OBJECTS][NDIM];
memset(percep, 0, NUM_OBJECTS*NDIM*sizeof(double));
double debug[NUM_OBJECTS][NDIM];
memset(debug, 0, NUM_OBJECTS*NDIM*sizeof(double));
size_t frame_size;
// Open files for debug
for( int i = 0; i < NUM_OBJECTS; ++i ) {
char name[50];
sprintf( name, "logging_est%d.txt", i );
pF.push_back(fopen( name, "w+"));
}
int counter = 0;
while( true ) {
if( counter > 60 ) {
std::cout << "Getting out of loop"<< std::endl;
break;
}
// PERCEP CHANNEL
r = ach_get( &channel, &percep,
sizeof(percep),
&frame_size,
NULL,
ACH_O_WAIT );
std::cout << "Received traj (visible, x, y, angle): " << std::endl;
print_arr_2d( percep, NUM_OBJECTS );
// DEBUG CHANNEL
r = ach_get( &debug_channel, &debug,
sizeof(debug),
&frame_size,
NULL,
ACH_O_WAIT );
std::cout << "[DEBUG] Received traj (visible, x, y, angle): " << std::endl;
print_arr_2d( debug, NUM_OBJECTS );
// Store them (to cm and to degrees)
for( int i = 0; i < NUM_OBJECTS; ++i ) {
fprintf( pF[i], " %f %f %f %f %f %f \n", percep[i][0]*100.0, percep[i][1]*100.0, percep[i][2]*57.3, debug[i][0]*100.0, debug[i][1]*100.0, debug[i][2]*57.3 );
}
// Read every second
usleep(0.25*1e6);
counter++;
}
return 0;
}
int main(int argc, char * argv[])
{
bfd * bfd_in;
bfd * bfd_out;
char * filename_in;
char * filename_out;
log_init(PROGRAM_NAME, LOG_MESSAGE);
atexit(log_fini);
filename_in = NULL;
filename_out = NULL;
int c;
// int digit_optind = 0;
while (1) {
// int this_option_optind = optind ? optind : 1;
int option_index = 0;
static struct option long_options[] = {
{ "input", 1, 0, 'i' },
{ "output", 1, 0, 'o' },
{ "debug", 0, 0, 'd' },
{ "verbose", 0, 0, 'v' },
{ "version", 0, 0, 'V' },
{ "help", 0, 0, 'h' },
{ 0, 0, 0, 0 }
};
c = getopt_long(argc, argv, "i:o:dvVh",
long_options, &option_index);
if (c == -1) {
break;
}
debug("Handling option character '%c'\n", c);
switch (c) {
case 'i':
filename_in = optarg;
break;
case 'o':
filename_out = optarg;
break;
case 'd':
log_level(LOG_DEBUG);
break;
case 'v':
log_level(LOG_VERBOSE);
break;
case 'V':
version(PROGRAM_NAME);
return 0;
case 'h':
help();
return 0;
case '?':
hint(PROGRAM_NAME, "Unrecognized option");
return 1;
default:
BUG();
return 1;
}
}
if (!filename_in) {
fatal("Missing input filename\n");
exit(EXIT_FAILURE);
}
if (!filename_out) {
fatal("Missing output filename\n");
exit(EXIT_FAILURE);
}
/* XXX FIXME: Use stat instead of strcmp */
if (!strcmp(filename_in, filename_out)) {
fatal("Input and output are the same file\n");
exit(EXIT_FAILURE);
}
bfd_init();
debug("Reading input file %s\n", filename_in);
bfd_in = bfd_openr(filename_in, NULL);
if (!bfd_in) {
fatal("Cannot open input file %s (%s)\n",
filename_in, BFD_strerror());
exit(EXIT_FAILURE);
}
if (!bfd_check_format(bfd_in, bfd_object)) {
fatal("Wrong input file format (not an object)\n");
exit(EXIT_FAILURE);
}
bfd_out = bfd_openw(filename_out, NULL);
if (!bfd_out) {
fatal("Cannot open output file %s (%s)\n",
filename_out, BFD_strerror());
exit(EXIT_FAILURE);
}
debug("Generating output file %s\n", filename_out);
bfd_set_format(bfd_out, bfd_get_format(bfd_in));
if (bfd_copy_private_bfd_data(bfd_in, bfd_out) == FALSE) {
fatal("Cannot copy private bfd data (%s)\n",
BFD_strerror());
exit(EXIT_FAILURE);
}
if (bfd_copy_private_header_data(bfd_in, bfd_out) == FALSE) {
fatal("Cannot copy private header data (%s)\n",
BFD_strerror());
exit(EXIT_FAILURE);
}
bfd_close(bfd_in);
bfd_close(bfd_out);
exit(EXIT_SUCCESS);
}
/* create font based on window type, charater attributes and
window device context */
HGDIOBJ
mswin_get_font(int win_type, int attr, HDC hdc, BOOL replace)
{
HFONT fnt = NULL;
LOGFONT lgfnt;
int font_size;
int font_index;
static BOOL once = FALSE;
if (!once) {
once = TRUE;
atexit(font_table_cleanup);
}
ZeroMemory(&lgfnt, sizeof(lgfnt));
/* try find font in the table */
for (font_index = 0; font_index < font_table_size; font_index++)
if (NHFONT_CODE(win_type, attr) == font_table[font_index].code)
break;
if (!replace && font_index < font_table_size)
return font_table[font_index].hFont;
switch (win_type) {
case NHW_STATUS:
lgfnt.lfHeight = -iflags.wc_fontsiz_status
* GetDeviceCaps(hdc, LOGPIXELSY)
/ 72; // height of font
lgfnt.lfWidth = 0; // average character width
lgfnt.lfEscapement = 0; // angle of escapement
lgfnt.lfOrientation = 0; // base-line orientation angle
lgfnt.lfWeight = FW_NORMAL; // font weight
lgfnt.lfItalic = FALSE; // italic attribute option
lgfnt.lfUnderline = FALSE; // underline attribute option
lgfnt.lfStrikeOut = FALSE; // strikeout attribute option
lgfnt.lfCharSet = mswin_charset(); // character set identifier
lgfnt.lfOutPrecision = OUT_DEFAULT_PRECIS; // output precision
lgfnt.lfClipPrecision = CLIP_DEFAULT_PRECIS; // clipping precision
lgfnt.lfQuality = DEFAULT_QUALITY; // output quality
if (iflags.wc_font_status && *iflags.wc_font_status) {
lgfnt.lfPitchAndFamily = DEFAULT_PITCH; // pitch and family
NH_A2W(iflags.wc_font_status, lgfnt.lfFaceName, LF_FACESIZE);
} else {
lgfnt.lfPitchAndFamily = FIXED_PITCH; // pitch and family
}
break;
case NHW_MENU:
lgfnt.lfHeight = -iflags.wc_fontsiz_menu
* GetDeviceCaps(hdc, LOGPIXELSY)
/ 72; // height of font
lgfnt.lfWidth = 0; // average character width
lgfnt.lfEscapement = 0; // angle of escapement
lgfnt.lfOrientation = 0; // base-line orientation angle
lgfnt.lfWeight = (attr == ATR_BOLD || attr == ATR_INVERSE)
? FW_BOLD
: FW_NORMAL; // font weight
lgfnt.lfItalic =
(attr == ATR_BLINK) ? TRUE : FALSE; // italic attribute option
lgfnt.lfUnderline =
(attr == ATR_ULINE) ? TRUE : FALSE; // underline attribute option
lgfnt.lfStrikeOut = FALSE; // strikeout attribute option
lgfnt.lfCharSet = mswin_charset(); // character set identifier
lgfnt.lfOutPrecision = OUT_DEFAULT_PRECIS; // output precision
lgfnt.lfClipPrecision = CLIP_DEFAULT_PRECIS; // clipping precision
lgfnt.lfQuality = DEFAULT_QUALITY; // output quality
if (iflags.wc_font_menu && *iflags.wc_font_menu) {
lgfnt.lfPitchAndFamily = DEFAULT_PITCH; // pitch and family
NH_A2W(iflags.wc_font_menu, lgfnt.lfFaceName, LF_FACESIZE);
} else {
lgfnt.lfPitchAndFamily = FIXED_PITCH; // pitch and family
}
break;
case NHW_MESSAGE:
font_size = (attr == ATR_INVERSE) ? iflags.wc_fontsiz_message + 1
: iflags.wc_fontsiz_message;
lgfnt.lfHeight = -font_size * GetDeviceCaps(hdc, LOGPIXELSY)
/ 72; // height of font
lgfnt.lfWidth = 0; // average character width
lgfnt.lfEscapement = 0; // angle of escapement
lgfnt.lfOrientation = 0; // base-line orientation angle
lgfnt.lfWeight = (attr == ATR_BOLD || attr == ATR_INVERSE)
? FW_BOLD
: FW_NORMAL; // font weight
lgfnt.lfItalic =
(attr == ATR_BLINK) ? TRUE : FALSE; // italic attribute option
lgfnt.lfUnderline =
(attr == ATR_ULINE) ? TRUE : FALSE; // underline attribute option
lgfnt.lfStrikeOut = FALSE; // strikeout attribute option
lgfnt.lfCharSet = mswin_charset(); // character set identifier
lgfnt.lfOutPrecision = OUT_DEFAULT_PRECIS; // output precision
lgfnt.lfClipPrecision = CLIP_DEFAULT_PRECIS; // clipping precision
lgfnt.lfQuality = DEFAULT_QUALITY; // output quality
if (iflags.wc_font_message && *iflags.wc_font_message) {
lgfnt.lfPitchAndFamily = DEFAULT_PITCH; // pitch and family
NH_A2W(iflags.wc_font_message, lgfnt.lfFaceName, LF_FACESIZE);
} else {
lgfnt.lfPitchAndFamily = VARIABLE_PITCH; // pitch and family
}
break;
case NHW_TEXT:
lgfnt.lfHeight = -iflags.wc_fontsiz_text
* GetDeviceCaps(hdc, LOGPIXELSY)
/ 72; // height of font
lgfnt.lfWidth = 0; // average character width
lgfnt.lfEscapement = 0; // angle of escapement
lgfnt.lfOrientation = 0; // base-line orientation angle
lgfnt.lfWeight = (attr == ATR_BOLD || attr == ATR_INVERSE)
? FW_BOLD
: FW_NORMAL; // font weight
lgfnt.lfItalic =
(attr == ATR_BLINK) ? TRUE : FALSE; // italic attribute option
lgfnt.lfUnderline =
(attr == ATR_ULINE) ? TRUE : FALSE; // underline attribute option
lgfnt.lfStrikeOut = FALSE; // strikeout attribute option
lgfnt.lfCharSet = mswin_charset(); // character set identifier
lgfnt.lfOutPrecision = OUT_DEFAULT_PRECIS; // output precision
lgfnt.lfClipPrecision = CLIP_DEFAULT_PRECIS; // clipping precision
lgfnt.lfQuality = DEFAULT_QUALITY; // output quality
if (iflags.wc_font_text && *iflags.wc_font_text) {
lgfnt.lfPitchAndFamily = DEFAULT_PITCH; // pitch and family
NH_A2W(iflags.wc_font_text, lgfnt.lfFaceName, LF_FACESIZE);
} else {
lgfnt.lfPitchAndFamily = FIXED_PITCH; // pitch and family
}
break;
}
fnt = CreateFontIndirect(&lgfnt);
/* add font to the table */
if (font_index == font_table_size) {
if (font_table_size >= MAXFONTS)
panic("font table overflow!");
font_table_size++;
} else {
DeleteObject(font_table[font_index].hFont);
}
font_table[font_index].code = NHFONT_CODE(win_type, attr);
font_table[font_index].hFont = fnt;
return fnt;
}