/* check target VE RATE on destination node */
int check_rate(struct string_list *rate)
{
int rc = 0;
struct string_list_el *r;
char *str, *p, *dev, *id;
struct string_list iflist;
struct string_list idlist;
logger(LOG_DEBUG, "check rate");
string_list_init(&iflist);
string_list_init(&idlist);
if ((rc = read_iflist(&iflist)))
return rc;
if ((rc = read_idlist(&idlist)))
return rc;
string_list_for_each(rate, r) {
/* parse rate record */
if ((str = strdup(r->s)) == NULL)
return putErr(MIG_ERR_SYSTEM, MIG_MSG_SYSTEM);
dev = str;
if ((p = strchr(str, ':')) == NULL) {
rc = putErr(MIG_ERR_RATE, "invalid rate : %s", r->s);
goto cleanup;
}
*p = '\0';
id = p + 1;
if ((p = strchr(id, ':')) == NULL) {
rc = putErr(MIG_ERR_RATE, "invalid rate : %s", r->s);
goto cleanup;
}
*p = '\0';
/* check interface */
if (strcmp(dev, "*")) {
if (string_list_find(&iflist, dev) == NULL) {
rc = putErr(MIG_ERR_RATE,
"rate device %s not found", dev);
goto cleanup;
}
}
/* check class id */
if (strcmp(id, "*")) {
if (string_list_find(&idlist, id) == NULL) {
rc = putErr(MIG_ERR_RATE,
"rate class %s not found", id);
goto cleanup;
}
}
cleanup:
free((void *)str);
if (rc)
break;
}
string_list_clean(&idlist);
string_list_clean(&iflist);
return rc;
}
void resolve_init(void)
{
query = vstring_alloc(100);
channel = vstring_alloc(100);
nexthop = vstring_alloc(100);
nextrcpt = vstring_alloc(100);
if (*var_virt_alias_doms)
virt_alias_doms =
string_list_init(MATCH_FLAG_NONE, var_virt_alias_doms);
if (*var_virt_mailbox_doms)
virt_mailbox_doms =
string_list_init(MATCH_FLAG_NONE, var_virt_mailbox_doms);
if (*var_relay_domains)
relay_domains =
domain_list_init(match_parent_style(VAR_RELAY_DOMAINS),
var_relay_domains);
if (*var_relocated_maps)
relocated_maps =
maps_create(VAR_RELOCATED_MAPS, var_relocated_maps,
DICT_FLAG_LOCK);
}
int main(int argc, char **argv)
{
STRING_LIST *list;
char *string;
int ch;
msg_vstream_init(argv[0], VSTREAM_ERR);
while ((ch = GETOPT(argc, argv, "v")) > 0) {
switch (ch) {
case 'v':
msg_verbose++;
break;
default:
usage(argv[0]);
}
}
if (argc != optind + 2)
usage(argv[0]);
list = string_list_init(MATCH_FLAG_NONE, argv[optind]);
string = argv[optind + 1];
vstream_printf("%s: %s\n", string, string_list_match(list, string) ?
"YES" : "NO");
vstream_fflush(VSTREAM_OUT);
string_list_free(list);
}
int VEObj::operateVE(const char * func, const char * action,
const char ** options, int quiet)
{
int rc, i;
string_list argv;
if (action && !quiet)
logger(LOG_INFO, "%s CT %s ...", action, ctid());
string_list_init(&argv);
string_list_add(&argv, BIN_VZCTL);
if (quiet)
string_list_add(&argv, "--quiet");
string_list_add(&argv, "--skiplock");
string_list_add(&argv, "--skipowner");
string_list_add(&argv, "--ignore-ha-cluster");
string_list_add(&argv, (char *)func);
string_list_add(&argv, ctid());
if (options) {
for (i = 0; options[i]; i++)
string_list_add(&argv, (char *)options[i]);
}
rc = vzml_execve(&argv, NULL, -1, -1, quiet);
string_list_clean(&argv);
if (action && (rc == 0) && !quiet)
logger(LOG_INFO, "done");
return rc;
}
/* Stores the variables occurring in the string in variables_set. */
static void
note_variables (const char *string)
{
string_list_init (&variables_set);
find_variables (string, ¬e_variable);
string_list_sort (&variables_set);
}
void string_list_clean (string_list * list)
{
for (size_t i = 0; i < list->length; ++i)
free (list->list[i]);
free (list->list);
string_list_init (list);
}
/* Return a pointer to a new menu item */
MenuItem*
MenuItem::create(MenuItemKind kind_, const char *text_, int init_toggle_, Menu* target_menu_, int id, int* int_p_)
{
MenuItem *pnew_item = new MenuItem;
pnew_item->kind = kind_;
pnew_item->text = (char*) malloc(sizeof(char) * (strlen(text_) + 1));
strcpy(pnew_item->text, text_);
if(kind_ == MN_TOGGLE)
pnew_item->toggled = init_toggle_;
else
pnew_item->toggled = false;
pnew_item->target_menu = target_menu_;
pnew_item->input = (char*) malloc(sizeof(char));
pnew_item->input[0] = '\0';
if(kind_ == MN_STRINGSELECT)
{
pnew_item->list = (string_list_type*) malloc(sizeof(string_list_type));
string_list_init(pnew_item->list);
}
else
pnew_item->list = NULL;
pnew_item->id = id;
pnew_item->int_p = int_p_;
pnew_item->input_flickering = false;
pnew_item->input_flickering_timer.init(true);
pnew_item->input_flickering_timer.start(FLICK_CURSOR_TIME);
return pnew_item;
}
static int packed_transaction_prepare(struct ref_store *ref_store,
struct ref_transaction *transaction,
struct strbuf *err)
{
struct packed_ref_store *refs = packed_downcast(
ref_store,
REF_STORE_READ | REF_STORE_WRITE | REF_STORE_ODB,
"ref_transaction_prepare");
struct packed_transaction_backend_data *data;
size_t i;
int ret = TRANSACTION_GENERIC_ERROR;
/*
* Note that we *don't* skip transactions with zero updates,
* because such a transaction might be executed for the side
* effect of ensuring that all of the references are peeled or
* ensuring that the `packed-refs` file is sorted. If the
* caller wants to optimize away empty transactions, it should
* do so itself.
*/
data = xcalloc(1, sizeof(*data));
string_list_init(&data->updates, 0);
transaction->backend_data = data;
/*
* Stick the updates in a string list by refname so that we
* can sort them:
*/
for (i = 0; i < transaction->nr; i++) {
struct ref_update *update = transaction->updates[i];
struct string_list_item *item =
string_list_append(&data->updates, update->refname);
/* Store a pointer to update in item->util: */
item->util = update;
}
string_list_sort(&data->updates);
if (ref_update_reject_duplicates(&data->updates, err))
goto failure;
if (!is_lock_file_locked(&refs->lock)) {
if (packed_refs_lock(ref_store, 0, err))
goto failure;
data->own_lock = 1;
}
if (write_with_updates(refs, &data->updates, err))
goto failure;
transaction->state = REF_TRANSACTION_PREPARED;
return 0;
failure:
packed_transaction_cleanup(refs, transaction);
return ret;
}
void resolve_local_init(void)
{
/* Allow on-the-fly update to make testing easier. */
if (resolve_local_list)
string_list_free(resolve_local_list);
resolve_local_list = string_list_init(VAR_MYDEST, MATCH_FLAG_RETURN,
var_mydest);
}
int read_repository_format(struct repository_format *format, const char *path)
{
memset(format, 0, sizeof(*format));
format->version = -1;
format->is_bare = -1;
string_list_init(&format->unknown_extensions, 1);
git_config_from_file(check_repo_format, path, format);
return format->version;
}
const char *check_user_acl_byuid(char *acl, uid_t uid)
{
struct mypasswd *mypwd;
STRING_LIST *list;
static VSTRING *who = 0;
int matched;
const char *name;
/*
* Optimize for the most common case. This also makes Postfix a little
* more robust in the face of local infrastructure failures. Note that we
* only need to match the "static:" substring, not the result value.
*/
if (strncmp(acl, DICT_TYPE_STATIC ":", sizeof(DICT_TYPE_STATIC)) == 0)
return (0);
/*
* XXX: Substitute "unknown" for UIDs without username, so that
* static:anyone results in "permit" even when the uid is not found in
* the password file, and so that a pattern of !unknown can be used to
* block non-existent accounts.
*
* The alternative is to use the UID as a surrogate lookup key for
* non-existent accounts. There are several reasons why this is not a
* good idea. 1) An ACL with a numerical UID should work regardless of
* whether or not an account has a password file entry. Therefore we
* would always have search on the numerical UID whenever the username
* fails to produce a match. 2) The string-list infrastructure is not
* really suitable for mixing numerical and non-numerical user
* information, because the numerical match is done in a separate pass
* from the non-numerical match. This breaks when the ! operator is used.
*
* XXX To avoid waiting until the lookup completes (e.g., LDAP or NIS down)
* invoke mypwuid_err(), and either change the user_acl() API to
* propagate the error to the caller, or treat lookup errors as fatal.
*/
if ((mypwd = mypwuid(uid)) == 0) {
name = "unknown";
} else {
name = mypwd->pw_name;
}
list = string_list_init(MATCH_FLAG_NONE, acl);
if ((matched = string_list_match(list, name)) == 0) {
if (!who)
who = vstring_alloc(10);
vstring_strcpy(who, name);
}
string_list_free(list);
if (mypwd)
mypwfree(mypwd);
return (matched ? 0 : vstring_str(who));
}
void smtp_sasl_initialize(void)
{
/*
* Sanity check.
*/
if (smtp_sasl_passwd_map || smtp_sasl_impl)
msg_panic("smtp_sasl_initialize: repeated call");
if (*var_smtp_sasl_passwd == 0)
msg_fatal("specify a password table via the `%s' configuration parameter",
VAR_SMTP_SASL_PASSWD);
/*
* Open the per-host password table and initialize the SASL library. Use
* shared locks for reading, just in case someone updates the table.
*/
smtp_sasl_passwd_map = maps_create("smtp_sasl_passwd",
var_smtp_sasl_passwd,
DICT_FLAG_LOCK | DICT_FLAG_FOLD_FIX);
if ((smtp_sasl_impl = xsasl_client_init(var_smtp_sasl_type,
var_smtp_sasl_path)) == 0)
msg_fatal("SASL library initialization");
/*
* Initialize optional supported mechanism matchlist
*/
if (*var_smtp_sasl_mechs)
smtp_sasl_mechs = string_list_init(MATCH_FLAG_NONE,
var_smtp_sasl_mechs);
/*
* Initialize the 535 SASL authentication failure cache.
*/
if (*var_smtp_sasl_auth_cache_name) {
#ifdef HAVE_SASL_AUTH_CACHE
smtp_sasl_auth_cache =
smtp_sasl_auth_cache_init(var_smtp_sasl_auth_cache_name,
var_smtp_sasl_auth_cache_time);
#else
msg_warn("not compiled with TLS support -- "
"ignoring the " VAR_SMTP_SASL_AUTH_CACHE_NAME " setting");
#endif
}
}
/* 0 - ipadd, 1 - ipdel*/
static int ipset(const char *ctid, const char *cmd, struct string_list *iplist)
{
int rc;
struct string_list argv;
struct string_list_el *p;
if (string_list_empty(iplist))
return 0;
string_list_init(&argv);
string_list_add(&argv, BIN_VZCTL);
string_list_add(&argv, "--skiplock");
string_list_add(&argv, "--skipowner");
string_list_add(&argv, "set");
string_list_add(&argv, ctid);
string_list_for_each(iplist, p) {
string_list_add(&argv, cmd);
string_list_add(&argv, p->s);
}
void db_common_parse_domain(CFG_PARSER *parser, void *ctxPtr)
{
DB_COMMON_CTX *ctx = (DB_COMMON_CTX *) ctxPtr;
char *domainlist;
const char *myname = "db_common_parse_domain";
domainlist = cfg_get_str(parser, "domain", "", 0, 0);
if (*domainlist) {
ctx->domain = string_list_init(MATCH_FLAG_NONE, domainlist);
if (ctx->domain == 0)
/*
* The "domain" optimization skips input keys that may in fact
* have unwanted matches in the database, so failure to create
* the match list is fatal.
*/
msg_fatal("%s: %s: domain match list creation using '%s' failed",
myname, parser->name, domainlist);
}
myfree(domainlist);
}
/**
* The entry point for the submit folder list thread.
*
* @param msg
* @return
*/
static int imap_submit_folder_list_entry(struct imap_submit_folder_list_entry_msg *msg)
{
struct imap_server *server = imap_duplicate(msg->server);
struct string_list list;
struct string_node *node;
string_list_init(&list);
node = string_list_first(msg->list);
while (node)
{
string_list_insert_tail(&list,node->string);
node = string_node_next(node);
}
if (thread_parent_task_can_contiue())
{
struct imap_submit_folder_options options = {0};
thread_call_function_async(thread_get_main(),status_init,1,0);
thread_call_function_async(thread_get_main(),status_open,0);
options.server = server;
options.list = &list;
options.callbacks.set_status = imap_set_status;
options.callbacks.set_status_static = imap_set_status_static;
options.callbacks.set_connect_to_server = imap_set_connect_to_server;
options.callbacks.set_head = imap_set_head;
options.callbacks.set_title = imap_set_title;
options.callbacks.set_title_utf8 = imap_set_title_utf8;
imap_submit_folder_list_really(&options);
thread_call_function_async(thread_get_main(),status_close,0);
}
string_list_clear(&list);
return 0;
}
static int graph_write(int argc, const char **argv)
{
struct string_list *pack_indexes = NULL;
struct string_list *commit_hex = NULL;
struct string_list lines;
static struct option builtin_commit_graph_write_options[] = {
OPT_STRING(0, "object-dir", &opts.obj_dir,
N_("dir"),
N_("The object directory to store the graph")),
OPT_BOOL(0, "reachable", &opts.reachable,
N_("start walk at all refs")),
OPT_BOOL(0, "stdin-packs", &opts.stdin_packs,
N_("scan pack-indexes listed by stdin for commits")),
OPT_BOOL(0, "stdin-commits", &opts.stdin_commits,
N_("start walk at commits listed by stdin")),
OPT_BOOL(0, "append", &opts.append,
N_("include all commits already in the commit-graph file")),
OPT_END(),
};
argc = parse_options(argc, argv, NULL,
builtin_commit_graph_write_options,
builtin_commit_graph_write_usage, 0);
if (opts.reachable + opts.stdin_packs + opts.stdin_commits > 1)
die(_("use at most one of --reachable, --stdin-commits, or --stdin-packs"));
if (!opts.obj_dir)
opts.obj_dir = get_object_directory();
read_replace_refs = 0;
if (opts.reachable) {
write_commit_graph_reachable(opts.obj_dir, opts.append, 1);
return 0;
}
string_list_init(&lines, 0);
if (opts.stdin_packs || opts.stdin_commits) {
struct strbuf buf = STRBUF_INIT;
while (strbuf_getline(&buf, stdin) != EOF)
string_list_append(&lines, strbuf_detach(&buf, NULL));
if (opts.stdin_packs)
pack_indexes = &lines;
if (opts.stdin_commits)
commit_hex = &lines;
UNLEAK(buf);
}
write_commit_graph(opts.obj_dir,
pack_indexes,
commit_hex,
opts.append,
1);
UNLEAK(lines);
return 0;
}
string_list_type dfiles(const char *rel_path, const char* glob, const char* exception_str)
{
DIR *dirStructP;
struct dirent *direntp;
string_list_type sdirs;
char path[1024];
string_list_init(&sdirs);
sprintf(path,"%s/%s",st_dir,rel_path);
if((dirStructP = opendir(path)) != NULL)
{
while((direntp = readdir(dirStructP)) != NULL)
{
char absolute_filename[1024];
struct stat buf;
sprintf(absolute_filename, "%s/%s", path, direntp->d_name);
if (stat(absolute_filename, &buf) == 0 && S_ISREG(buf.st_mode))
{
if(exception_str != NULL)
{
if(strstr(direntp->d_name,exception_str) != NULL)
continue;
}
if(glob != NULL)
if(strstr(direntp->d_name,glob) == NULL)
continue;
string_list_add_item(&sdirs,direntp->d_name);
}
}
closedir(dirStructP);
}
sprintf(path,"%s/%s",datadir.c_str(),rel_path);
if((dirStructP = opendir(path)) != NULL)
{
while((direntp = readdir(dirStructP)) != NULL)
{
char absolute_filename[1024];
struct stat buf;
sprintf(absolute_filename, "%s/%s", path, direntp->d_name);
if (stat(absolute_filename, &buf) == 0 && S_ISREG(buf.st_mode))
{
if(exception_str != NULL)
{
if(strstr(direntp->d_name,exception_str) != NULL)
continue;
}
if(glob != NULL)
if(strstr(direntp->d_name,glob) == NULL)
continue;
string_list_add_item(&sdirs,direntp->d_name);
}
}
closedir(dirStructP);
}
return sdirs;
}
int cmd_main(int argc, const char **argv)
{
struct strbuf buf = STRBUF_INIT;
int nongit;
setup_git_directory_gently(&nongit);
if (argc < 2) {
error("remote-curl: usage: git remote-curl <remote> [<url>]");
return 1;
}
options.verbosity = 1;
options.progress = !!isatty(2);
options.thin = 1;
string_list_init(&options.deepen_not, 1);
string_list_init(&options.push_options, 1);
remote = remote_get(argv[1]);
if (argc > 2) {
end_url_with_slash(&url, argv[2]);
} else {
end_url_with_slash(&url, remote->url[0]);
}
http_init(remote, url.buf, 0);
do {
const char *arg;
if (strbuf_getline_lf(&buf, stdin) == EOF) {
if (ferror(stdin))
error("remote-curl: error reading command stream from git");
return 1;
}
if (buf.len == 0)
break;
if (starts_with(buf.buf, "fetch ")) {
if (nongit)
die("remote-curl: fetch attempted without a local repo");
parse_fetch(&buf);
} else if (!strcmp(buf.buf, "list") || starts_with(buf.buf, "list ")) {
int for_push = !!strstr(buf.buf + 4, "for-push");
output_refs(get_refs(for_push));
} else if (starts_with(buf.buf, "push ")) {
parse_push(&buf);
} else if (skip_prefix(buf.buf, "option ", &arg)) {
char *value = strchr(arg, ' ');
int result;
if (value)
*value++ = '\0';
else
value = "true";
result = set_option(arg, value);
if (!result)
printf("ok\n");
else if (result < 0)
printf("error invalid value\n");
else
printf("unsupported\n");
fflush(stdout);
} else if (!strcmp(buf.buf, "capabilities")) {
printf("stateless-connect\n");
printf("fetch\n");
printf("option\n");
printf("push\n");
printf("check-connectivity\n");
printf("\n");
fflush(stdout);
} else if (skip_prefix(buf.buf, "stateless-connect ", &arg)) {
if (!stateless_connect(arg))
break;
} else {
error("remote-curl: unknown command '%s' from git", buf.buf);
return 1;
}
strbuf_reset(&buf);
} while (1);
http_cleanup();
return 0;
}
/* Note: The user has to free the allocated space. */
string_list_type dsubdirs(const char *rel_path,const char* expected_file)
{
DIR *dirStructP;
struct dirent *direntp;
string_list_type sdirs;
char filename[1024];
char path[1024];
string_list_init(&sdirs);
sprintf(path,"%s/%s",st_dir,rel_path);
if((dirStructP = opendir(path)) != NULL)
{
while((direntp = readdir(dirStructP)) != NULL)
{
char absolute_filename[1024];
struct stat buf;
sprintf(absolute_filename, "%s/%s", path, direntp->d_name);
if (stat(absolute_filename, &buf) == 0 && S_ISDIR(buf.st_mode))
{
if(expected_file != NULL)
{
sprintf(filename,"%s/%s/%s",path,direntp->d_name,expected_file);
if(!faccessible(filename))
continue;
}
string_list_add_item(&sdirs,direntp->d_name);
}
}
closedir(dirStructP);
}
sprintf(path,"%s/%s",datadir.c_str(),rel_path);
if((dirStructP = opendir(path)) != NULL)
{
while((direntp = readdir(dirStructP)) != NULL)
{
char absolute_filename[1024];
struct stat buf;
sprintf(absolute_filename, "%s/%s", path, direntp->d_name);
if (stat(absolute_filename, &buf) == 0 && S_ISDIR(buf.st_mode))
{
if(expected_file != NULL)
{
sprintf(filename,"%s/%s/%s",path,direntp->d_name,expected_file);
if(!faccessible(filename))
{
continue;
}
else
{
sprintf(filename,"%s/%s/%s/%s",st_dir,rel_path,direntp->d_name,expected_file);
if(faccessible(filename))
continue;
}
}
string_list_add_item(&sdirs,direntp->d_name);
}
}
closedir(dirStructP);
}
return sdirs;
}
/* --- TITLE SCREEN --- */
void title(void)
{
random_timer.init(true);
walking = true;
st_pause_ticks_init();
GameSession session(datadir + "/levels/misc/menu.stl", 0, ST_GL_DEMO_GAME);
clearscreen(0, 0, 0);
updatescreen();
/* Load images: */
bkg_title = new Surface(datadir + "/images/title/background.jpg", IGNORE_ALPHA);
logo = new Surface(datadir + "/images/title/logo.png", USE_ALPHA);
img_choose_subset = new Surface(datadir + "/images/status/choose-level-subset.png", USE_ALPHA);
/* Generating contrib maps by only using a string_list */
// Since there isn't any world dir or anything, add a hardcoded entry for Bonus Island
string_list_init(&worldmap_list);
string_list_type files = dfiles("levels/worldmaps/", ".stwm", "couldn't list worldmaps");
for(int i = 0; i < files.num_items; ++i) {
if(strcmp(files.item[i], "world1.stwm") == 0)
continue;
string_list_add_item(&worldmap_list, files.item[i]);
}
string_list_free(&files);
/* --- Main title loop: --- */
frame = 0;
/* Draw the title background: */
bkg_title->draw_bg();
update_time = st_get_ticks();
random_timer.start(rand() % 2000 + 2000);
Menu::set_current(main_menu);
while (Menu::current())
{
// if we spent to much time on a menu entry
if( (update_time - last_update_time) > 1000)
update_time = last_update_time = st_get_ticks();
// Calculate the movement-factor
double frame_ratio = ((double)(update_time-last_update_time))/((double)FRAME_RATE);
if(frame_ratio > 1.5) /* Quick hack to correct the unprecise CPU clocks a little bit. */
frame_ratio = 1.5 + (frame_ratio - 1.5) * 0.85;
/* Lower the frame_ratio that Tux doesn't jump to hectically throught the demo. */
frame_ratio /= 2;
SDL_Event event;
while (SDL_PollEvent(&event))
{
if (Menu::current())
{
Menu::current()->event(event);
}
// FIXME: QUIT signal should be handled more generic, not locally
if (event.type == SDL_QUIT)
Menu::set_current(0);
}
/* Draw the background: */
draw_demo(&session, frame_ratio);
if (Menu::current() == main_menu)
logo->draw( 160, 30);
white_small_text->draw(" SuperTux " VERSION "\n"
"Copyright (c) 2003 SuperTux Devel Team\n"
"This game comes with ABSOLUTELY NO WARRANTY. This is free software, and you\n"
"are welcome to redistribute it under certain conditions; see the file COPYING\n"
"for details.\n",
0, 420, 0);
/* Don't draw menu, if quit is true */
Menu* menu = Menu::current();
if(menu)
{
menu->draw();
menu->action();
if(menu == main_menu)
{
MusicManager* music_manager;
MusicRef menu_song;
switch (main_menu->check())
{
case MNID_STARTGAME:
// Start Game, ie. goto the slots menu
update_load_save_game_menu(load_game_menu);
break;
case MNID_CONTRIB:
// Contrib Menu
puts("Entering contrib menu");
generate_contrib_menu();
break;
case MNID_LEVELEDITOR:
leveleditor();
Menu::set_current(main_menu);
break;
case MNID_CREDITS:
music_manager = new MusicManager();
menu_song = music_manager->load_music(datadir + "/music/credits.ogg");
music_manager->halt_music();
music_manager->play_music(menu_song,0);
display_text_file("CREDITS", bkg_title, SCROLL_SPEED_CREDITS);
music_manager->halt_music();
menu_song = music_manager->load_music(datadir + "/music/theme.mod");
music_manager->play_music(menu_song);
Menu::set_current(main_menu);
break;
case MNID_QUITMAINMENU:
Menu::set_current(0);
break;
}
}
else if(menu == options_menu)
{
process_options_menu();
}
else if(menu == load_game_menu)
{
if(event.key.keysym.sym == SDLK_DELETE)
{
int slot = menu->get_active_item_id();
char str[1024];
sprintf(str,"Are you sure you want to delete slot %d?", slot);
draw_background();
if(confirm_dialog(str))
{
sprintf(str,"%s/slot%d.stsg", st_save_dir, slot);
printf("Removing: %s\n",str);
remove(str);
}
update_load_save_game_menu(load_game_menu);
update_time = st_get_ticks();
Menu::set_current(main_menu);
}
else if (process_load_game_menu())
{
// FIXME: shouldn't be needed if GameSession doesn't relay on global variables
// reset tux
scroll_x = 0;
//titletux.level_begin();
update_time = st_get_ticks();
}
}
else if(menu == contrib_menu)
{
check_contrib_menu();
}
else if (menu == contrib_subset_menu)
{
check_contrib_subset_menu();
}
}
mouse_cursor->draw();
flipscreen();
/* Set the time of the last update and the time of the current update */
last_update_time = update_time;
update_time = st_get_ticks();
/* Pause: */
frame++;
SDL_Delay(25);
}
/* Free surfaces: */
free_contrib_menu();
string_list_free(&worldmap_list);
delete bkg_title;
delete logo;
delete img_choose_subset;
}
/**
* Execute the command READCSS to read a CSS file
*
* @param nerr
* Error Return Flag
* - 0 on Success
*
* @date 970403: New option to conveniently select the channel.
* @date 970206: New option to specify which magnitude to read. maf
* @date 961216: Now filtering on station rather than gain. maf
* @date 920420: Changed null string, "", to ' ' - porting to IBM.
* @date 910703: add # to parameter keyword GAIN;
* add * as a legal value for params GAIN, BAND, ORIENT
* @date 910402: New code.
*
*/
void
xrcss(int *nerr) {
char _c0[2];
char file[MCMSG+1];
int len;
int lmore, lshift, lscale, larray ;
int nchar;
static int Verbose = 0;
static int ibinORasc;
static string_list *last_list = NULL;
double memory_max;
memory_max = 0.30;
char kmag[4] ; /* magnitude type: mb, ms, or ml. maf 970206 */
string_list *list;
if(!last_list) {
last_list = string_list_init();
}
*nerr = 0;
list = string_list_init();
/* PARSING PHASE: */
/* - Parse position-dependent tokens: */
lmore = FALSE;
while ( lcmore( nerr ) ){
/* -- "MORE": signifies addition of more files to current read
* filelist rather than replacement of current list with new one */
if( lckey( "MORE#$",7 ) && cmdfm.ndfl > 0 ){
lmore = TRUE;
continue ;
}
/* -- "VERBOSE ON|OFF": turn Verbose mode on or off. */
else if( lklog( "VER$BOSE",9, &Verbose ) ){
continue ;
}
/* -- "SHIFT ON|OFF": turn calibration on or off. */
else if( lklog( "SHIFT$",7, &lshift ) ){
cmdfm.lshift = lshift ;
continue ;
}
/* -- "SCALE ON|OFF": turn scaling on or off. */
else if( lklog( "SCALE$",7, &lscale ) ){
cmdfm.lscale = lscale ;
continue ;
}
/* -- "ARRAY ON|OFF": turn lienient array behavior on or off. */
else if ( lklog ( "ARRAY$" , 7 , &larray ) ) {
cmdfm.larray = larray ;
continue ;
}
/* -- "MAXMEM v": change maximum fractional memory used by SeisMgr*/
else if( lkreal( "MAX#MEM$",9, &memory_max ) )
{
MaxMem = memory_max;
}
/* -- "DIR CURRENT|name": set the name of the default subdirectory*/
else if(lkchar("DIR#$",6,MCPFN,kmdfm.krdcssdir,MCPFN+1,&nchar)){
if( memcmp(kmdfm.krdcssdir,"CURRENT",7) == 0 ||
memcmp(kmdfm.krdcssdir ,"current",7) == 0 ){
cfmt( "ILLEGAL PARAM VALUE: current",30 );
cresp();
return ;
}
else if( kmdfm.krdcssdir[nchar - 1] != KDIRDL ){
_c0[0] = KDIRDL;
_c0[1] = '\0';
subscpy( kmdfm.krdcssdir, nchar, -1, MCPFN, _c0 );
}
continue;
}
/* -- "MAGNITUDE|mb|ms|ml|def": specify a field for magnitude, or
if def is found, use the algorithm to determine which
magnitude to read. maf 970206. */
else if ( lkchar ( "MAG#NITUDE$", 12 , 4 , kmag , 4 , &nchar ) ) {
if ( kmag [ 0 ] == 'm' || kmag[ 0 ] == 'M' ) {
if ( kmag [ 1 ] == 'b' || kmag [ 1 ] == 'B' )
cmdfm.nMagSpec = MbMag ;
else if ( kmag [ 1 ] == 's' || kmag [ 1 ] == 'S' )
cmdfm.nMagSpec = MsMag ;
else if ( kmag [ 1 ] == 'l' || kmag [ 1 ] == 'L' )
cmdfm.nMagSpec = MlMag ;
else {
cfmt( "ILLEGAL PARAM VALUE:",22 );
cresp();
return ;
}
} /* end if ( kmag [ 0 ] == 'm' ... ) */
else if ( strncmp ( kmag , "def" , 3 ) == 0 ||
strncmp ( kmag , "DEF" , 3 ) == 0 )
cmdfm.nMagSpec = Any ;
else {
cfmt( "ILLEGAL PARAM VALUE:",22 );
cresp();
return ;
}
} /* end if ( lkchar ( "MAG#NITUDE$", ... ) */
/* -- "STATION": whether wfdisc record fld 'sta' matches given */
/* string. maf 961216 */
else if( lklogc("STA#TION$",10,&kmdfm.lstation,kmdfm.kstation,7 ) ){
char *ptr ;
ptr = strchr ( kmdfm.kstation , ' ' ) ;
if ( ptr != NULL )
*ptr = '\0' ;
continue;
}
/* -- "CHANNEL": whether wfdisc record fld 'chan' matches the
* given string. maf 970403 */
else if( lklogc("CHAN#NEL$",10,&kmdfm.lchannel,kmdfm.kchannel,9 ) ){
char *ptr ;
ptr = strchr ( kmdfm.kchannel , ' ' ) ;
if ( ptr != NULL )
*ptr = '\0' ;
//if( jcdflbeg > 0 && jcdflend == 0 )
// jcdflend = jcparmbeg - 1;
continue;
}
/* -- "BANDWIDTH": whether wfdisc record fld 'chan' has a leading
* letter which is S(short), M(medium), or L(long) */
else if( lklogc( "BAND#WIDTH$",12, &kmdfm.lbandw,kmdfm.kbandw,9 ) ){
//if( jcdflbeg > 0 && jcdflend == 0 )
//jcdflend = jcparmbeg - 1;
continue;
} /* end else if( lklogc( "BAND#WIDTH$" ... */
/* -- "ORIENTATION: whether wfdisc record fld 'chan' has a second
* letter which is N(north), E(east), or Z(vertical) */
else if(lklogc("ORIENT#ATION$",14,&kmdfm.lorient,kmdfm.korient,9)){
//if( jcdflbeg > 0 && jcdflend == 0 )
//jcdflend = jcparmbeg - 1;
continue;
} /* end else if( lklogc( "ORIENT#ATION$" ... */
/* -- TRUST: whether or not to trust matching evids while moving
data from SAC buffers to CSS buffers. */
else if( lklog( "TRUST#$",8, &cmdfm.ltrust ) )
{ /* do nothing */ }
/* -- "COMMIT|RECALLTRACE|ROLLBACK":
how to treat existing data */
else if ( lckeyExact ( "COMMIT" , 7 ) )
cmdfm.icomORroll = COMMIT ;
else if (lckeyExact ( "RECALLTRACE" , 12 ) )
cmdfm.icomORroll = RECALL ;
else if ( lckeyExact ( "RECALL" , 7 ) )
cmdfm.icomORroll = RECALL ;
else if ( lckeyExact ( "ROLLBACK" , 9 ) )
cmdfm.icomORroll = ROLLBACK ;
/* -- "BINARY|ASCII": CSSB versus flat files */
else if( lclist( (char*)kmdfm.kbinORasc,9, 2, &ibinORasc ) ) {
cmdfm.lrascii = ibinORasc - 1 ;
}
/* -- Else assume it to be beginning/continuing dfl, if not
* recognized as above
* Use kdflin as dummy buffer to skip a string */
else if(lcchar(MCMSG, file, MCMSG+1, &len)) {
string_list_put(list, file, len);
}
}
/* - The above loop is over when one of two conditions has been met:
* (1) An error in parsing has occurred. In this case NERR is > 0 .
* (2) All the tokens in the command have been successfully parsed. */
if( *nerr != 0 )
return ;
if(string_list_length(list) <= 0) {
string_list_extend(list, last_list);
}
/* EXECUTION PHASE: */
/* - Commit or rollback data according to lmore and cmdfm.icomORroll */
if ( lmore ) {
alignFiles ( nerr ) ;
if ( *nerr )
return ;
cmdfm.nfilesFirst = cmdfm.ndfl ;
} /* end if */
else {
cmdfm.nreadflag = HIGH ;
cmdfm.nfilesFirst = 0 ;
}
/* Copy Current List to Last_List */
string_list_clear(last_list);
string_list_extend(last_list, list);
/* - Expand the filelist and read the files into memory.
* -- Parameter kstation, kband, korient are picked up in readcfl from
* ../../inc/dfm */
readcfl( lmore, kmdfm.krdcssdir,MCPFN+1, list,
Verbose, cmdfm.lrascii, MaxMem, nerr );
string_list_free(list);
list = NULL;
return;
}
static void pre_jail_init(char *unused_name, char **unused_argv)
{
VSTRING *redirect;
/*
* Open read-only maps before dropping privilege, for consistency with
* other Postfix daemons.
*/
psc_acl_pre_jail_init(var_mynetworks, VAR_PSC_ACL);
if (*var_psc_acl)
psc_acl = psc_acl_parse(var_psc_acl, VAR_PSC_ACL);
/* Ignore smtpd_forbid_cmds lookup errors. Non-critical feature. */
if (*var_psc_forbid_cmds)
psc_forbid_cmds = string_list_init(MATCH_FLAG_RETURN,
var_psc_forbid_cmds);
if (*var_psc_dnsbl_reply)
psc_dnsbl_reply = dict_open(var_psc_dnsbl_reply, O_RDONLY,
DICT_FLAG_DUP_WARN);
/*
* Never, ever, get killed by a master signal, as that would corrupt the
* database when we're in the middle of an update.
*/
if (setsid() < 0)
msg_warn("setsid: %m");
/*
* Security: don't create root-owned files that contain untrusted data.
* And don't create Postfix-owned files in root-owned directories,
* either. We want a correct relationship between (file or directory)
* ownership and (file or directory) content. To open files before going
* to jail, temporarily drop root privileges.
*/
SAVE_AND_SET_EUGID(var_owner_uid, var_owner_gid);
redirect = vstring_alloc(100);
/*
* Keep state in persistent external map. As a safety measure we sync the
* database on each update. This hurts on LINUX file systems that sync
* all dirty disk blocks whenever any application invokes fsync().
*
* Start the cache maintenance pseudo thread after dropping privileges.
*/
#define PSC_DICT_OPEN_FLAGS (DICT_FLAG_DUP_REPLACE | DICT_FLAG_SYNC_UPDATE | \
DICT_FLAG_OPEN_LOCK)
if (*var_psc_cache_map)
psc_cache_map =
dict_cache_open(data_redirect_map(redirect, var_psc_cache_map),
O_CREAT | O_RDWR, PSC_DICT_OPEN_FLAGS);
/*
* Clean up and restore privilege.
*/
vstring_free(redirect);
RESTORE_SAVED_EUGID();
/*
* Initialize the dummy SMTP engine.
*/
psc_smtpd_pre_jail_init();
}
int main(int argc, char **argv)
{
int rc = 0;
SSL_METHOD *meth = NULL;
SSL * ssl = NULL;
SSL_CTX * ctx = NULL;
X509 *server_cert = NULL;
long res;
char *srv;
int sd, ferr;
unsigned long addr;
struct sockaddr_in saddr;
unsigned short port = 4422;
int lcipher;
struct string_list arglist;
char *dir, *name;
char path[PATH_MAX+1];
if ( argc < 3 )
usage(basename(argv[0]), 1);
if (parse_cmd_line(argc, argv))
usage(basename(argv[0]), 1);
if (argc <= optind+1)
usage(basename(argv[0]), 1);
srv = argv[optind];
strncpy(path, argv[optind+1], sizeof(path));
name = basename(path);
dir = dirname(path);
if ((addr = inet_addr(srv)) == INADDR_NONE) {
/* need to resolve address */
struct hostent *host;
if ((host = gethostbyname(srv)) == NULL) {
fprintf(stderr, "gethostbyname(%s) err : %m\n", srv);
return 1;
}
memcpy(&addr, host->h_addr, sizeof(addr));
}
if (crtfile == NULL)
crtfile = strdup("certificate.pem");
if (keyfile == NULL)
keyfile = strdup("private.key");
if (ciphers == NULL)
lcipher = 0;
else if (strcasecmp(ciphers, "none") == 0)
lcipher = 0;
else
lcipher = 1;
string_list_init(&arglist);
string_list_add(&arglist, "tar");
string_list_add(&arglist, "-c");
string_list_add(&arglist, "-S");
string_list_add(&arglist, "--ignore-failed-read");
string_list_add(&arglist, "-f");
string_list_add(&arglist, "-");
string_list_add(&arglist, "-C");
string_list_add(&arglist, dir);
string_list_add(&arglist, name);
/* Set up the library */
SSL_library_init();
SSL_load_error_strings();
/* Create SSL context (framework) */
meth = SSLv23_client_method();
if ((ctx = SSL_CTX_new(meth)) == NULL) {
fprintf(stderr, "SSL_CTX_new() : %m\n");
ERR_print_errors_fp(stderr);
rc = 1;
goto cleanup_0;
}
/* load certificat from file */
if(SSL_CTX_use_certificate_file(ctx, crtfile, SSL_FILETYPE_PEM) < 1) {
ERR_print_errors_fp(stderr);
rc = 1;
goto cleanup_1;
}
if(SSL_CTX_use_PrivateKey_file(ctx, keyfile, SSL_FILETYPE_PEM) < 1) {
ERR_print_errors_fp(stdout);
rc = 1;
goto cleanup_1;
}
if (lcipher) {
/* load available cipher list */
if (SSL_CTX_set_cipher_list(ctx, ciphers) == 0) {
fprintf(stderr, "Error loading cipher list\n");
ERR_print_errors_fp(stderr);
rc = 1;
goto cleanup_1;
}
}
SSL_CTX_set_verify(ctx,
SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT, NULL);
/* ----------------------------------------------- */
/* Create a socket and connect to server using normal socket calls. */
if ((sd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
fprintf(stderr, "socket() err : %m\n");
rc = 1;
goto cleanup_1;
}
saddr.sin_family = AF_INET;
saddr.sin_addr.s_addr = addr;
saddr.sin_port = htons(port);
if (connect(sd, (struct sockaddr *)&saddr, sizeof(saddr))) {
// if (errno != EINPROGRESS) - for NONBLOCK
fprintf(stderr, "connect() : %m\n");
rc = 1;
goto cleanup_1;
}
/* ----------------------------------------------- */
/* Now we have TCP connection. Start SSL negotiation. */
/* Create SSL obj */
if ((ssl = SSL_new(ctx)) == NULL) {
fprintf(stderr, "Error creating SSL object\n");
ERR_print_errors_fp(stderr);
rc = 1;
goto cleanup_1;
}
SSL_set_fd(ssl, sd);
SSL_set_mode(ssl, SSL_MODE_AUTO_RETRY);
/* try to connect */
if(SSL_connect(ssl) <= 0) {
fprintf(stderr, "Error attempting to connect\n");
/* TODO SSL_get_error() */
ERR_print_errors_fp(stderr);
rc = 1;
goto cleanup_2;
}
/* Get server's certificate. Note: dynamic allocation */
if ((server_cert = SSL_get_peer_certificate(ssl)) == NULL) {
fprintf(stderr, "Can't get peer certificate\n");
ERR_print_errors_fp(stderr);
rc = 1;
goto cleanup_2;
}
X509_free(server_cert);
/* verify the certificate
From SSL_get_verify_result() man page:
If no peer certificate was presented, the returned result code is
X509_V_OK. This is because no verification error occurred, it does how-
ever not indicate success. SSL_get_verify_result() is only useful in
connection with SSL_get_peer_certificate(3).
*/
res = SSL_get_verify_result(ssl);
/* will use expired certificate for test */
if ( (res != X509_V_OK) &&
(res != X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT) &&
(res != X509_V_ERR_CERT_HAS_EXPIRED)) {
fprintf(stderr, "Certificate verification error: %ld\n", res);
fprintf(stderr, "See verify man page for more info\n");
ERR_print_errors_fp(stderr);
rc = 1;
goto cleanup_2;
}
printf("Server certificate verified\n");
ferr = dup(STDERR_FILENO);
if (lcipher)
;
else {
rc = run_rw(sd, sd, ferr, &arglist);
}
close(ferr);
printf("rc = %d\n", rc);
SSL_shutdown(ssl);
/* Close the connection and free the context */
cleanup_2:
if (ssl)
SSL_free(ssl);
cleanup_1:
if (ctx)
SSL_CTX_free(ctx);
cleanup_0:
string_list_clean(&arglist);
return rc;
}
void cleanup_pre_jail(char *unused_name, char **unused_argv)
{
static const NAME_MASK send_canon_class_table[] = {
CANON_CLASS_ENV_FROM, CLEANUP_CANON_FLAG_ENV_FROM,
CANON_CLASS_HDR_FROM, CLEANUP_CANON_FLAG_HDR_FROM,
0,
};
static const NAME_MASK rcpt_canon_class_table[] = {
CANON_CLASS_ENV_RCPT, CLEANUP_CANON_FLAG_ENV_RCPT,
CANON_CLASS_HDR_RCPT, CLEANUP_CANON_FLAG_HDR_RCPT,
0,
};
static const NAME_MASK canon_class_table[] = {
CANON_CLASS_ENV_FROM, CLEANUP_CANON_FLAG_ENV_FROM,
CANON_CLASS_ENV_RCPT, CLEANUP_CANON_FLAG_ENV_RCPT,
CANON_CLASS_HDR_FROM, CLEANUP_CANON_FLAG_HDR_FROM,
CANON_CLASS_HDR_RCPT, CLEANUP_CANON_FLAG_HDR_RCPT,
0,
};
static const NAME_MASK masq_class_table[] = {
MASQ_CLASS_ENV_FROM, CLEANUP_MASQ_FLAG_ENV_FROM,
MASQ_CLASS_ENV_RCPT, CLEANUP_MASQ_FLAG_ENV_RCPT,
MASQ_CLASS_HDR_FROM, CLEANUP_MASQ_FLAG_HDR_FROM,
MASQ_CLASS_HDR_RCPT, CLEANUP_MASQ_FLAG_HDR_RCPT,
0,
};
if (*var_canonical_maps)
cleanup_comm_canon_maps =
maps_create(VAR_CANONICAL_MAPS, var_canonical_maps,
DICT_FLAG_LOCK | DICT_FLAG_FOLD_FIX);
if (*var_send_canon_maps)
cleanup_send_canon_maps =
maps_create(VAR_SEND_CANON_MAPS, var_send_canon_maps,
DICT_FLAG_LOCK | DICT_FLAG_FOLD_FIX);
if (*var_rcpt_canon_maps)
cleanup_rcpt_canon_maps =
maps_create(VAR_RCPT_CANON_MAPS, var_rcpt_canon_maps,
DICT_FLAG_LOCK | DICT_FLAG_FOLD_FIX);
if (*var_virt_alias_maps)
cleanup_virt_alias_maps = maps_create(VAR_VIRT_ALIAS_MAPS,
var_virt_alias_maps,
DICT_FLAG_LOCK
| DICT_FLAG_FOLD_FIX);
if (*var_canon_classes)
cleanup_comm_canon_flags =
name_mask(VAR_CANON_CLASSES, canon_class_table,
var_canon_classes);
if (*var_send_canon_classes)
cleanup_send_canon_flags =
name_mask(VAR_CANON_CLASSES, send_canon_class_table,
var_send_canon_classes);
if (*var_rcpt_canon_classes)
cleanup_rcpt_canon_flags =
name_mask(VAR_CANON_CLASSES, rcpt_canon_class_table,
var_rcpt_canon_classes);
if (*var_masq_domains)
cleanup_masq_domains = argv_split(var_masq_domains, " ,\t\r\n");
if (*var_header_checks)
cleanup_header_checks =
maps_create(VAR_HEADER_CHECKS, var_header_checks, DICT_FLAG_LOCK);
if (*var_mimehdr_checks)
cleanup_mimehdr_checks =
maps_create(VAR_MIMEHDR_CHECKS, var_mimehdr_checks, DICT_FLAG_LOCK);
if (*var_nesthdr_checks)
cleanup_nesthdr_checks =
maps_create(VAR_NESTHDR_CHECKS, var_nesthdr_checks, DICT_FLAG_LOCK);
if (*var_body_checks)
cleanup_body_checks =
maps_create(VAR_BODY_CHECKS, var_body_checks, DICT_FLAG_LOCK);
if (*var_masq_exceptions)
cleanup_masq_exceptions =
string_list_init(MATCH_FLAG_NONE, var_masq_exceptions);
if (*var_masq_classes)
cleanup_masq_flags = name_mask(VAR_MASQ_CLASSES, masq_class_table,
var_masq_classes);
if (*var_send_bcc_maps)
cleanup_send_bcc_maps =
maps_create(VAR_SEND_BCC_MAPS, var_send_bcc_maps,
DICT_FLAG_LOCK | DICT_FLAG_FOLD_FIX);
if (*var_rcpt_bcc_maps)
cleanup_rcpt_bcc_maps =
maps_create(VAR_RCPT_BCC_MAPS, var_rcpt_bcc_maps,
DICT_FLAG_LOCK | DICT_FLAG_FOLD_FIX);
if (*var_cleanup_milters)
cleanup_milters = milter_create(var_cleanup_milters,
var_milt_conn_time,
var_milt_cmd_time,
var_milt_msg_time,
var_milt_protocol,
var_milt_def_action,
var_milt_conn_macros,
var_milt_helo_macros,
var_milt_mail_macros,
var_milt_rcpt_macros,
var_milt_data_macros,
var_milt_eoh_macros,
var_milt_eod_macros,
var_milt_unk_macros);
flush_init();
}
/**
* Write a File to disk
*
* @param lsdd
* Set the Output to be a SDD file
* @param nerr
* Error Return Flag
* - 0 on Success
*
* @date 970702: Changed lckey and lkchar to lckeyExact and lkcharExact
* throughout xw.c. This will allow files to begin with
* the same string as the various options (eg. sacxz.021.z)
* maf.
* @date 910731: Bug fixed in options PREPEND, DELETE, CHANGE.
* @date 900904: Added SDD as a format for write.
* @date 881228: Added four new options for generating write file list
* from data file list: APPEND, PREPEND, CHANGE, DELETE.
* @date 880204: Fixed logic involving use of DIR option in READ and WRITE
* by adding an ON/OFF flag as well as a directory name.
* @date 880115: Deleted call that forced default directory to lowercase.
* @date 870626: Added default directory option.
* @date 860917: Changed to character lists for storing data file names.
* @date 850730: Deleted SOCKITTOME format.
* @date 830120: Added SOCK and CI output formats.
* @date 820721: Changed to newest set of parsing and checking functions.
* @date 810120: Changed to output message retrieval from disk.
* @date 810203: Fixed bug in file overwrite option.
*
*/
void
xw(int lsdd,
int *nerr) {
int i;
char delimiter[2], kcdir[9], kchange[MCPFN+1], kdirpart[MCPFN+1];
char kfile[MCPFN+1], kpdir[9], kstring[MCPFN+1], ktemp[9];
int lexpnd;
int jdfl, nchange, nchar, nchg, ndx1, ndx2;
int nlen, nstr, nstring, nwrdir;
static int lwrdir = FALSE;
char *cattemp;
char *strtemp1, *strtemp2, *strtemp3;
char *file;
string_list *list, *files;
kschan[12]='\0';
kschdr[80]='\0';
ksclas[4]='\0';
kscom[40]='\0';
ksevnm[8]='\0';
ksfrmt[8]='\0';
ksstnm[8]='\0';
memset(kfile, 0, sizeof(kfile));
memset(kdirpart, 0, sizeof(kdirpart));
memset(kchange, 0, sizeof(kchange));
memset(ktemp, 0, sizeof(ktemp));
memset(kstring, 0, sizeof(kstring));
memset(kpdir, 0, sizeof(kpdir));
memset(kcdir, 0, sizeof(kcdir));
memset(delimiter, 0, sizeof(delimiter));
lexpnd = FALSE;
*nerr = 0;
files = string_list_init();
list = NULL;
if( lsdd )
cmdfm.iwfmt = 3;
/* PARSING PHASE: */
/* - Loop on each token in command: */
while ( lcmore( nerr ) ){
/* -- "SAC|ALPHA": set format to be used in writing files. */
if( lckeyExact( "SAC#$",6 ) )
cmdfm.iwfmt = 1;
else if( lckeyExact( "ALPHA#$",8 ) )
cmdfm.iwfmt = 2;
else if( lckeyExact( "CI#$",5 ) )
cmdfm.iwfmt = 2;
else if( lckeyExact( "SDD#$",6 ) )
cmdfm.iwfmt = 3;
else if( lckeyExact( "XDR#$",6 ) ) {
cmdfm.iwfmt = 4;
}
else if( lckeyExact( "SEGY#$", 7 ) )
cmdfm.iwfmt = 5;
/* -- "OVER": overwrite files from previous READ command. */
else if( lckeyExact( "OVER#$",7 ) ){
cmdfm.lovrrq = TRUE;
lexpnd = FALSE;
string_list_extend(files, datafiles);
}
/* generate names from the KSTCMP header field */
else if( lckeyExact( "KSTCMP#$",9 ) ){
lexpnd = FALSE;
gennames("KSTCMP ",7,files,string_list_length(datafiles),nerr);
if(*nerr != 0)
goto L_8888;
}
/* -- "APPEND string": append string to filenames from READ command. */
else if( lkcharExact( "APPEND#$",9, MCPFN, kstring,MCPFN+1, &nstring ) ){
for(i = 0; i < cmdfm.ndfl; i++) {
strtemp1 = string_list_get(datafiles, i);
appendstring( kstring,MCPFN+1, strtemp1, strlen(strtemp1)+2, kfile,MCPFN+1 );
string_list_put(files, kfile, MCPFN+1);
if( *nerr != 0 )
goto L_8888;
}
cmdfm.lovrrq = FALSE;
lexpnd = TRUE;
}
/* -- "PREPEND string": prepend string to filenames from READ command. */
else if( lkcharExact( "PREPEND#$",10, MCPFN, kstring,MCPFN+1, &nstring ) ){
for(i = 0; i < cmdfm.ndfl; i++) {
strtemp1 = malloc(nstring+1);
strncpy(strtemp1,kstring,nstring);
strtemp1[nstring] = '\0';
strtemp2 = string_list_get(datafiles, i);
prependstring( strtemp1, nstring+1, strtemp2, strlen(strtemp2)+2, kfile,MCPFN+1);
free(strtemp1);
string_list_put(files, kfile, MCPFN+1);
if( *nerr != 0 )
goto L_8888;
}
cmdfm.lovrrq = FALSE;
lexpnd = TRUE;
}
/* -- "DELETE string": delete string from filenames from READ command. */
else if( lkcharExact( "DELETE#$",9, MCPFN, kstring,MCPFN+1, &nstring ) ){
for(i = 0; i < cmdfm.ndfl; i++) {
strtemp1 = malloc(nstring+1);
strncpy(strtemp1,kstring,nstring);
strtemp1[nstring] = '\0';
strtemp2 = string_list_get(datafiles, i);
deletestring( strtemp1, nstring+1, strtemp2, strlen(strtemp2)+2, kfile,MCPFN+1);
free(strtemp1);
string_list_put(files, kfile, MCPFN+1);
if( *nerr != 0 )
goto L_8888;
}
cmdfm.lovrrq = FALSE;
lexpnd = TRUE;
}
/* -- "CHANGE string1 string2": change string1 to string2 in READ filenames. */
else if( lkcharExact( "CHANGE#$",9, MCPFN, kstring,MCPFN+1, &nstring ) ){
lcchar( MCPFN, kchange,MCPFN+1, &nchange );
for(i = 0; i < cmdfm.ndfl; i++) {
nstr = indexb( kstring,MCPFN+1 );
nchg = indexb( kchange,MCPFN+1 );
strtemp1 = malloc(nstr+1);
strtemp2 = malloc(nchg+1);
strncpy(strtemp1,kstring,nstr);
strncpy(strtemp2,kchange,nchg);
strtemp1[nstr] = '\0';
strtemp2[nchg] = '\0';
strtemp3 = string_list_get(datafiles, i);
changestring( strtemp1, nstr+1, strtemp2, nchg+1,
strtemp3, strlen(strtemp3)+2, kfile,MCPFN+1 );
free(strtemp1);
free(strtemp2);
string_list_put(files, kfile, MCPFN+1);
if( *nerr != 0 )
goto L_8888;
}
cmdfm.lovrrq = FALSE;
lexpnd = TRUE;
}
/* -- "DIR ON|OFF|CURRENT|name": set the name of the default subdirectory. */
else if( lkcharExact( "DIR#$",6, MCPFN, kmdfm.kwrdir,MCPFN+1, &nchar ) ){
modcase( TRUE, kmdfm.kwrdir, MCPW, ktemp );
if( strncmp(ktemp,"OFF ",8) == 0 ) {
lwrdir = FALSE;
} else if( strncmp(ktemp,"CURRENT ",8) == 0 ){
lwrdir = TRUE;
fstrncpy( kmdfm.kwrdir, MCPFN, " ", 1);
} else if( kmdfm.kwrdir[nchar - 1] != KDIRDL ){
/* If the string is mising the "/" path separator */
lwrdir = TRUE;
delimiter[0] = KDIRDL;
delimiter[1] = '\0';
subscpy( kmdfm.kwrdir, nchar, -1, MCPFN, delimiter );
} else {
/* Path is not OFF, CURRENT and has the "/" at the end */
lwrdir = TRUE;
}
}
/* -- "COMMIT|RECALLTRACE|ROLLBACK":
how to treat existing data */
else if ( lckeyExact ( "COMMIT" , 7 ) )
cmdfm.icomORroll = COMMIT ;
else if (lckeyExact ( "RECALLTRACE" , 12 ) )
cmdfm.icomORroll = RECALL ;
else if ( lckeyExact ( "RECALL" , 7 ) )
cmdfm.icomORroll = RECALL ;
else if ( lckeyExact ( "ROLLBACK" , 9 ) )
cmdfm.icomORroll = ROLLBACK ;
/* -- "filelist": write files using names in new filelist. */
else if( ( list = lcdfl() ) ){
cmdfm.lovrrq = FALSE;
lexpnd = FALSE;
}
/* -- Bad syntax. */
else{
cfmt( "ILLEGAL OPTION:",17 );
cresp();
}
} /* end while ( lcmore( nerr ) ) */
/* - The above loop is over when one of two conditions has been met:
* (1) An error in parsing has occurred. In this case NERR is > 0 .
* (2) All the tokens in the command have been successfully parsed. */
if( *nerr != 0 )
goto L_8888;
/* CHECKING PHASE: */
if(!list) {
list = files;
} else {
/* List + Modifiers :: Use List */
string_list_free(files);
files = NULL;
}
/* - Check for null write filelist. */
if( string_list_length(list) <= 0 ){
*nerr = 1311;
setmsg( "ERROR", *nerr );
goto L_8888;
}
/* - Make sure the write filelist has as many entries as read filelist. */
if( string_list_length(list) != cmdfm.ndfl ){
*nerr = 1312;
error(1312, "%d %d", string_list_length(list), cmdfm.ndfl);
goto L_8888;
}
/* EXECUTION PHASE: */
/* - Commit or rollback data according to cmdfm.icomORroll */
alignFiles ( nerr ) ;
if ( *nerr )
return ;
/* - Echo expanded filelist if requested. */
if( cmdfm.lechof && lexpnd ){
setmsg( "OUTPUT", 0 );
for(i = 0; i < string_list_length(list); i++) {
file = string_list_get(list, i);
getdir( file, strlen(file)+1, kcdir,9, kfile,MCPFN+1 );
/* -- Echo the filename part if there is no directory part. */
if( strcmp(kcdir," ") == 0 )
apcmsg( kfile,MCPFN+1 );
/* -- Prepend the filename part with some special characters if
* directory part is same as that of the previous file. */
else if( memcmp(kcdir,kpdir,min(strlen(kcdir),strlen(kpdir)))
== 0 ){
cattemp = malloc(3+strlen(kfile)+1);
strcpy(cattemp, "...");
strcat(cattemp,kfile);
apcmsg( cattemp, 3+strlen(kfile)+1 );
free(cattemp);
}
/* -- Echo complete pathname if directory part is different. */
else{
apcmsg2(file, strlen(file)+1);
strcpy( kpdir, kcdir );
}
}
wrtmsg( MUNOUT );
}
/* - Write each file in memory to disk. */
nwrdir = indexb( kmdfm.kwrdir,MCPFN+1 );
for( jdfl = 1; jdfl <= cmdfm.ndfl; jdfl++ ){
/* -- Get file from memory manager. */
file = string_list_get(list, jdfl-1);
getfil( jdfl, TRUE, &nlen, &ndx1, &ndx2, nerr );
if( *nerr != 0 )
goto L_8888;
/* isolate file name */
file = string_list_get(list, jdfl-1);
/* -- Check overwrite-protect flag in header record. */
if( cmdfm.lovrrq && !*lovrok ){
*nerr = 1303;
setmsg( "ERROR", *nerr );
apcmsg2(file, strlen(file)+1);
outmsg () ;
clrmsg () ;
goto L_8888;
}
/* -- Prepare output file name:
* --- If directory option is ON (lwrdir=.TRUE. and nwrdir>0),
* concatenate directory name with file name part of write file list.
* --- If directory option is CURRENT (lwrdir=.TRUE. and nwrdir=0),
* use file name part of write file list.
* --- If directory option is OFF, use write file list. */
if( lwrdir ){
if( nwrdir > 0 ){
fstrncpy( kfile, MCPFN, kmdfm.kwrdir,min(nwrdir,MCPFN));
strtemp1 = file;
strtemp2 = malloc(130-(nwrdir+1));
strncpy(strtemp2,kfile+nwrdir,MCPFN+1-(nwrdir + 1));
strtemp2[MCPFN+1-(nwrdir+1)] = '\0';
getdir( strtemp1, strlen(strtemp1)+1,
kdirpart, MCPFN+1, strtemp2,-(nwrdir+1)+130);
subscpy(kfile,nwrdir,-1,MCPFN,strtemp2);
free(strtemp2);
}
else{
fstrncpy( kfile, MCPFN, " ", 1);
getdir( file, strlen(file)+1, kdirpart,MCPFN+1, kfile,MCPFN+1 );
}
}
else {
fstrncpy( kfile, MCPFN, file, strlen(file));
}
/* -- Write file in appropriate format. */
if( cmdfm.iwfmt == 2 )
wrci( jdfl, kfile,MCPFN+1, "%#15.7g", nerr );
else if( cmdfm.iwfmt == 3 )
wrsdd( jdfl, kfile,MCPFN+1, TRUE, nerr );
else if( cmdfm.iwfmt == 4 )
wrxdr( jdfl, kfile,MCPFN+1, TRUE, nerr );
else if( cmdfm.iwfmt == 5 )
wrsegy( jdfl , kfile , nerr ) ;
else
wrsac( jdfl, kfile,MCPFN+1, TRUE, nerr );
if( *nerr != 0 )
goto L_8888;
} /* end for ( jdfl ) */
L_8888:
return;
}
int ls(const char *path, ulong flags)
{
DIR *dir;
struct dirent *d;
char tmp[PATH_MAX];
struct stat s;
struct string_list sl;
string_list_init(&sl);
if (stat(path, &s))
return errno;
if (flags & LS_SHOWARG && s.st_mode & S_IFDIR)
printf("%s:\n", path);
if (!(s.st_mode & S_IFDIR)) {
ls_one(path, &s);
return 0;
}
dir = opendir(path);
if (!dir)
return errno;
while ((d = readdir(dir))) {
sprintf(tmp, "%s/%s", path, d->d_name);
if (stat(tmp, &s))
goto out;
if (flags & LS_COLUMN)
string_list_add_sorted(&sl, d->d_name);
else
ls_one(d->d_name, &s);
}
closedir(dir);
if (flags & LS_COLUMN) {
string_list_print_by_column(&sl);
string_list_free(&sl);
}
if (!(flags & LS_RECURSIVE))
return 0;
dir = opendir(path);
if (!dir) {
errno = -ENOENT;
return -ENOENT;
}
while ((d = readdir(dir))) {
if (!strcmp(d->d_name, "."))
continue;
if (!strcmp(d->d_name, ".."))
continue;
sprintf(tmp, "%s/%s", path, d->d_name);
if (stat(tmp, &s))
goto out;
if (s.st_mode & S_IFDIR) {
char *norm = normalise_path(tmp);
ls(norm, flags);
free(norm);
}
}
out:
closedir(dir);
return 0;
}
static void pre_init(char *unused_name, char **unused_argv)
{
int use_tls;
static const NAME_CODE addr_pref_map[] = {
INET_PROTO_NAME_IPV6, SMTP_MISC_FLAG_PREF_IPV6,
INET_PROTO_NAME_IPV4, SMTP_MISC_FLAG_PREF_IPV4,
INET_PROTO_NAME_ANY, 0,
0, -1,
};
/*
* Turn on per-peer debugging.
*/
debug_peer_init();
/*
* SASL initialization.
*/
if (var_smtp_sasl_enable)
#ifdef USE_SASL_AUTH
smtp_sasl_initialize();
#else
msg_warn("%s is true, but SASL support is not compiled in",
VAR_SMTP_SASL_ENABLE);
#endif
if (*var_smtp_tls_level != 0)
switch (tls_level_lookup(var_smtp_tls_level)) {
case TLS_LEV_SECURE:
case TLS_LEV_VERIFY:
case TLS_LEV_FPRINT:
case TLS_LEV_ENCRYPT:
var_smtp_use_tls = var_smtp_enforce_tls = 1;
break;
case TLS_LEV_MAY:
var_smtp_use_tls = 1;
var_smtp_enforce_tls = 0;
break;
case TLS_LEV_NONE:
var_smtp_use_tls = var_smtp_enforce_tls = 0;
break;
default:
/* tls_level_lookup() logs no warning. */
/* session_tls_init() assumes that var_smtp_tls_level is sane. */
msg_fatal("Invalid TLS level \"%s\"", var_smtp_tls_level);
}
use_tls = (var_smtp_use_tls || var_smtp_enforce_tls);
/*
* Initialize the TLS data before entering the chroot jail
*/
if (use_tls || var_smtp_tls_per_site[0] || var_smtp_tls_policy[0]) {
#ifdef USE_TLS
TLS_CLIENT_INIT_PROPS props;
int using_smtp = (strcmp(var_procname, "smtp") == 0);
/*
* We get stronger type safety and a cleaner interface by combining
* the various parameters into a single tls_client_props structure.
*
* Large parameter lists are error-prone, so we emulate a language
* feature that C does not have natively: named parameter lists.
*/
smtp_tls_ctx =
TLS_CLIENT_INIT(&props,
log_param = using_smtp ?
VAR_SMTP_TLS_LOGLEVEL : VAR_LMTP_TLS_LOGLEVEL,
log_level = var_smtp_tls_loglevel,
verifydepth = var_smtp_tls_scert_vd,
cache_type = using_smtp ?
TLS_MGR_SCACHE_SMTP : TLS_MGR_SCACHE_LMTP,
cert_file = var_smtp_tls_cert_file,
key_file = var_smtp_tls_key_file,
dcert_file = var_smtp_tls_dcert_file,
dkey_file = var_smtp_tls_dkey_file,
eccert_file = var_smtp_tls_eccert_file,
eckey_file = var_smtp_tls_eckey_file,
CAfile = var_smtp_tls_CAfile,
CApath = var_smtp_tls_CApath,
fpt_dgst = var_smtp_tls_fpt_dgst);
smtp_tls_list_init();
#else
msg_warn("TLS has been selected, but TLS support is not compiled in");
#endif
}
/*
* Flush client.
*/
flush_init();
/*
* Session cache domain list.
*/
if (*var_smtp_cache_dest)
smtp_cache_dest = string_list_init(MATCH_FLAG_RETURN, var_smtp_cache_dest);
/*
* EHLO keyword filter.
*/
if (*var_smtp_ehlo_dis_maps)
smtp_ehlo_dis_maps = maps_create(VAR_SMTP_EHLO_DIS_MAPS,
var_smtp_ehlo_dis_maps,
DICT_FLAG_LOCK);
/*
* PIX bug workarounds.
*/
if (*var_smtp_pix_bug_maps)
smtp_pix_bug_maps = maps_create(VAR_SMTP_PIX_BUG_MAPS,
var_smtp_pix_bug_maps,
DICT_FLAG_LOCK);
/*
* Generic maps.
*/
if (*var_prop_extension)
smtp_ext_prop_mask =
ext_prop_mask(VAR_PROP_EXTENSION, var_prop_extension);
if (*var_smtp_generic_maps)
smtp_generic_maps =
maps_create(VAR_SMTP_GENERIC_MAPS, var_smtp_generic_maps,
DICT_FLAG_LOCK | DICT_FLAG_FOLD_FIX);
/*
* Header/body checks.
*/
smtp_header_checks = hbc_header_checks_create(
VAR_SMTP_HEAD_CHKS, var_smtp_head_chks,
VAR_SMTP_MIME_CHKS, var_smtp_mime_chks,
VAR_SMTP_NEST_CHKS, var_smtp_nest_chks,
smtp_hbc_callbacks);
smtp_body_checks = hbc_body_checks_create(
VAR_SMTP_BODY_CHKS, var_smtp_body_chks,
smtp_hbc_callbacks);
/*
* Server reply filter.
*/
if (*var_smtp_resp_filter)
smtp_chat_resp_filter =
dict_open(var_smtp_resp_filter, O_RDONLY,
DICT_FLAG_LOCK | DICT_FLAG_FOLD_FIX);
/*
* Address family preference.
*/
if (*var_smtp_addr_pref) {
smtp_addr_pref = name_code(addr_pref_map, NAME_CODE_FLAG_NONE,
var_smtp_addr_pref);
if (smtp_addr_pref < 0)
msg_fatal("bad %s value: %s", VAR_SMTP_ADDR_PREF, var_smtp_addr_pref);
}
}
static int do_ls(struct command *cmdtp, int argc, char *argv[])
{
int ret, opt, o;
struct stat s;
ulong flags = LS_COLUMN;
struct string_list sl;
while((opt = getopt(argc, argv, "RCl")) > 0) {
switch(opt) {
case 'R':
flags |= LS_RECURSIVE | LS_SHOWARG;
break;
case 'C':
flags |= LS_COLUMN;
break;
case 'l':
flags &= ~LS_COLUMN;
break;
}
}
if (argc - optind > 1)
flags |= LS_SHOWARG;
if (optind == argc) {
ret = ls(getcwd(), flags);
return ret ? 1 : 0;
}
string_list_init(&sl);
o = optind;
/* first pass: all files */
while (o < argc) {
ret = stat(argv[o], &s);
if (ret) {
printf("%s: %s: %s\n", argv[0],
argv[o], errno_str());
o++;
continue;
}
if (!(s.st_mode & S_IFDIR)) {
if (flags & LS_COLUMN)
string_list_add_sorted(&sl, argv[o]);
else
ls_one(argv[o], &s);
}
o++;
}
if (flags & LS_COLUMN)
string_list_print_by_column(&sl);
string_list_free(&sl);
o = optind;
/* second pass: directories */
while (o < argc) {
ret = stat(argv[o], &s);
if (ret) {
o++;
continue;
}
if (s.st_mode & S_IFDIR) {
ret = ls(argv[o], flags);
if (ret) {
perror("ls");
o++;
continue;
}
}
o++;
}
return 0;
}