int main(int argc, char *argv[])
{
char *cmdline, **arglist;
char *prompt;
char **single_cmds;
int i, cmd_number;
int rv;
prompt = DEL_PROMPT;
setup();
exec_cmds = malloc(sizeof(char*) * MAXEXECCMDS);
while((cmdline = next_command(prompt, stdin)) != NULL)
{
single_cmds = split_command(cmdline);
for (i = 0; single_cmds[i] != '\0'; ++i)
{
if ((arglist = splitline(single_cmds[i])) != NULL)
{
// for those arglist executed later, we don't free it.
// we free later arglists in do_control_command's fi.
if ((rv = process(arglist)) != -1)
freelist(arglist);
}
}
freelist(single_cmds);
free(cmdline);
}
free(exec_cmds);
return 0;
}
int execute_command_line(char *line, char *argv[]) {
int num_of_commands = 0;
enum cmd_pos pos = unknown;
int left_pipe[2] = {-1, -1};
int right_pipe[2] = {-1, -1};
do {
// Repeat this loop for each of the commands separated by '|' in
// the command pipeline.
// Use the next_command() parser to get the position and argument
// vector of the next command in the command pipeline.
pos = next_command(line, argv);
create_pipe(pos, right_pipe);
fork_child(pos, left_pipe, right_pipe, argv);
// Only the parent will return here!!!
num_of_commands++;
// The previous rigth pipe now becomes the current left pipe.
shift_pipes(left_pipe, right_pipe);
} while (pos != single && pos != last);
return num_of_commands;
}
void control_up(int state)
{
if(r_DrawConsole)
next_command(state);
else
server_up(state);
}
int main(void)
{
enum cmd_pos pos;
char* argv[MAX_ARGV_SIZE];
char str[MAX_CMD_SIZE] = "cat parse.c | grep argv | wc -l";
do{
int i;
pos = next_command(str, argv);
for(i = 0; argv[i] != NULL; i++)
{
printf("argv[%d]: %s\n", i, argv[i]);
}
print_position(pos);
}while(pos != single && pos != last);
return 0;
}
/* Main loop of a slave thread.
* Send the current command to the slave machine and wait for a reply.
* Resend command history if the slave machine is out of sync.
* Returns when the connection with the slave machine is cut.
* slave_lock is held on both entry and exit of this function. */
static void
slave_loop(FILE *f, char *reply_buf, struct slave_state *sstate, bool resend)
{
char *to_send;
int last_cmd_count = 0;
int last_reply_id = -1;
int reply_slot = -1;
for (;;) {
if (resend) {
/* Resend complete or partial history */
to_send = next_command(last_reply_id);
} else {
/* Wait for a new command. */
while (last_cmd_count == cmd_count)
pthread_cond_wait(&cmd_cond, &slave_lock);
to_send = gtp_cmd;
}
/* Command available, send it to slave machine.
* If slave was out of sync, send the history.
* But first get binary arguments if necessary. */
int bin_size = 0;
void *bin_buf = get_binary_arg(sstate, gtp_cmd,
gtp_cmds + CMDS_SIZE - gtp_cmd,
&bin_size);
/* Check that the command is still valid. */
resend = true;
if (!bin_buf) continue;
/* Send the command and get the reply, which always ends with \n\n
* The slave machine sends "=id reply" or "?id reply"
* with id == cmd_id if it is in sync. */
last_cmd_count = cmd_count;
char buf[CMDS_SIZE];
int reply_id = send_command(to_send, bin_buf, &bin_size, f,
sstate, buf);
if (reply_id == -1) return;
resend = process_reply(reply_id, buf, reply_buf, bin_buf, bin_size,
&last_reply_id, &reply_slot, sstate);
}
}
t_exec *next_exec(t_exec *it, t_exec *list, t_env *ev)
{
int num;
if (ev->val_exit == 1)
return (next_command(list, it->prev));
if (it == list)
return (it);
num = elem_redirection(it->tab[0], "<<,>>,||,&&,<,>,|,&,;");
if (num == 7 || num == 8)
return (it->next);
else if (num == 1 || num == 2 || num == 5 || num == 6)
{
if (num == 1)
remove(".my_teemo");
if (it->next != list)
return (it->next->next);
else
return (it->next);
}
if (default_io(ev->stdin, ev->stdout, 3) == -1)
return (NULL);
return (it);
}
int main(int argc, char *argv[])
{
static char *cmdstr = NULL;
struct cmd_set **cmd_set;
static struct vfs_state vfs;
int i;
static char *filename = NULL;
/* make sure the vars that get altered (4th field) are in
a fixed location or certain compilers complain */
poptContext pc;
struct poptOption long_options[] = {
POPT_AUTOHELP
{"file", 'f', POPT_ARG_STRING, &filename, 0, },
{"command", 'c', POPT_ARG_STRING, &cmdstr, 0, "Execute specified list of commands" },
POPT_COMMON_SAMBA
POPT_TABLEEND
};
setlinebuf(stdout);
pc = poptGetContext("vfstest", argc, (const char **) argv,
long_options, 0);
while(poptGetNextOpt(pc) != -1);
poptFreeContext(pc);
/* TODO: check output */
reload_services(False);
/* the following functions are part of the Samba debugging
facilities. See lib/debug.c */
setup_logging("vfstest", True);
/* Load command lists */
cmd_set = vfstest_command_list;
while(*cmd_set) {
add_command_set(*cmd_set);
add_command_set(separator_command);
cmd_set++;
}
/* some basic initialization stuff */
sec_init();
conn_init();
vfs.conn = conn_new();
string_set(&vfs.conn->user,"vfstest");
for (i=0; i < 1024; i++)
vfs.files[i] = NULL;
/* some advanced initiliazation stuff */
smbd_vfs_init(vfs.conn);
/* Do we have a file input? */
if (filename && filename[0]) {
process_file(&vfs, filename);
return 0;
}
/* Do anything specified with -c */
if (cmdstr && cmdstr[0]) {
char *cmd;
char *p = cmdstr;
while((cmd=next_command(&p)) != NULL) {
process_cmd(&vfs, cmd);
}
return 0;
}
/* Loop around accepting commands */
while(1) {
pstring prompt;
char *line;
slprintf(prompt, sizeof(prompt) - 1, "vfstest $> ");
line = smb_readline(prompt, NULL, completion_fn);
if (line == NULL)
break;
if (line[0] != '\n')
process_cmd(&vfs, line);
}
free(vfs.conn);
return 0;
}
static int
execute_update_commands(WIMStruct *wim,
const struct wimlib_update_command *cmds,
size_t num_cmds,
int update_flags)
{
struct wim_inode_table *inode_table;
struct wim_sd_set *sd_set;
struct list_head unhashed_streams;
struct update_command_journal *j;
union wimlib_progress_info info;
int ret;
if (have_command_type(cmds, num_cmds, WIMLIB_UPDATE_OP_ADD)) {
/* If we have at least one "add" command, create the inode and
* security descriptor tables to index new inodes and new
* security descriptors, respectively. */
inode_table = alloca(sizeof(struct wim_inode_table));
sd_set = alloca(sizeof(struct wim_sd_set));
ret = init_inode_table(inode_table, 9001);
if (ret)
goto out;
ret = init_sd_set(sd_set, wim_get_current_security_data(wim));
if (ret)
goto out_destroy_inode_table;
INIT_LIST_HEAD(&unhashed_streams);
} else {
inode_table = NULL;
sd_set = NULL;
}
/* Start an in-memory journal to allow rollback if something goes wrong
*/
j = new_update_command_journal(num_cmds,
&wim_get_current_image_metadata(wim)->root_dentry,
wim->lookup_table);
if (!j) {
ret = WIMLIB_ERR_NOMEM;
goto out_destroy_sd_set;
}
info.update.completed_commands = 0;
info.update.total_commands = num_cmds;
ret = 0;
for (size_t i = 0; i < num_cmds; i++) {
DEBUG("Executing update command %zu of %zu (op=%"TS")",
i + 1, num_cmds, update_op_to_str(cmds[i].op));
info.update.command = &cmds[i];
if (update_flags & WIMLIB_UPDATE_FLAG_SEND_PROGRESS) {
ret = call_progress(wim->progfunc,
WIMLIB_PROGRESS_MSG_UPDATE_BEGIN_COMMAND,
&info, wim->progctx);
if (ret)
goto rollback;
}
switch (cmds[i].op) {
case WIMLIB_UPDATE_OP_ADD:
ret = execute_add_command(j, wim, &cmds[i], inode_table,
sd_set, &unhashed_streams);
break;
case WIMLIB_UPDATE_OP_DELETE:
ret = execute_delete_command(j, wim, &cmds[i]);
break;
case WIMLIB_UPDATE_OP_RENAME:
ret = execute_rename_command(j, wim, &cmds[i]);
break;
}
if (unlikely(ret))
goto rollback;
info.update.completed_commands++;
if (update_flags & WIMLIB_UPDATE_FLAG_SEND_PROGRESS) {
ret = call_progress(wim->progfunc,
WIMLIB_PROGRESS_MSG_UPDATE_END_COMMAND,
&info, wim->progctx);
if (ret)
goto rollback;
}
next_command(j);
}
commit_update(j);
if (inode_table) {
struct wim_image_metadata *imd;
imd = wim_get_current_image_metadata(wim);
list_splice_tail(&unhashed_streams, &imd->unhashed_streams);
inode_table_prepare_inode_list(inode_table, &imd->inode_list);
}
goto out_destroy_sd_set;
rollback:
if (sd_set)
rollback_new_security_descriptors(sd_set);
rollback_update(j);
out_destroy_sd_set:
if (sd_set)
destroy_sd_set(sd_set);
out_destroy_inode_table:
if (inode_table)
destroy_inode_table(inode_table);
out:
return ret;
}
/**
* DESCRIPTION:
*
* Prints a promt to the screen. Reads a command line of the following format from the the user:
*
* cmd0 -a00 -b01 ... -z0n | cmd1 | cmd2 | ... | cmdN -an0 ... -znn
*
* For each command, the fork_and_pipe() function is called with the
* appropiate argv and relative position of the command.
*
* NOTE:
*
* You only have to add code at the end of main, see TODO comment.
*/
int main() {
// Allocate a buffer for the command line read from the user.
char line_buffer[COMMAND_LINE_BUFFER_SIZE];
// We parse the command line using the next_command() parser. The
// parser will populate the following array with the result of each call
// to the parse.
char* argv[MAX_ARGV_SIZE];
// Count the number of non empty command lines.
int line_nr = 0;
// Position of each command in a command line.
enum cmd_pos pos; // {single, first, middle, last}
// Pipe read descriptor to the pipe to the "left".
int left_pipe_read_fd = -1;
// Count the number of children forked for each command line.
int children = 0;
while(1) {
do {
// Print the command prompt including the command line counter.
printf(" %d> ", line_nr);
fflush(NULL);
// Read input from the user.
if ( fgets(line_buffer, COMMAND_LINE_BUFFER_SIZE, stdin) == NULL) {
perror("====== ERROR ====> READING COMMAND LINE FAILED :(");
exit(EXIT_FAILURE);
}
// Exit if the user types "exit" and presses enter.
if (strcmp(line_buffer, "exit\n") == 0) {
printf(" Goodbye!\n");
exit(EXIT_SUCCESS);
}
// If the user presses enter without typing anything else, don't
// update the command line counter, just start over again.
} while (empty_line(line_buffer));
// We got some input from the user.
line_nr++;
// Parse the command line
do {
pos = next_command(line_buffer, argv);
// After the call to the next_command() parser function, the
// command possition within the command line is now available in the pos
// varialble.
DBG("\n%6s command %s\n", pos2str(pos), argv[0]);
// Loop through the argv and print the command data.
int i = 0;
while (argv[i] != NULL) {
DBG(" argv[%d] @ [0x%x] = \"%s\"\n", i, (unsigned int) argv[i], argv[i]);
i++;
}
// Create a pipe fork a new process for the command. We also
// must remember the read descriptor to the new pipe. This
// descriptor will become the read descriptor to the pipe to the
// "left" for the next command (if any).
left_pipe_read_fd = pipe_and_fork(pos, argv, left_pipe_read_fd);
children++;
// When are we done?
} while (pos != single && pos != last);
DBG("\nAfter calling next_command(), line [0x%X] ==>%s<==\n",
(unsigned int) &line_buffer, line_buffer);
// The parent goes here after after all children have been
// created for the command.
// TODO: Make sure shell doesn't print a new prompt until
// all the command processes (children) have terminated.
while(children>0){
wait(NULL);
children--;
}
} // end while(1)
} // end of main()
int start_rendering()
{
static int done = 0;
static void * network_thread_data[2] = { NULL, NULL };
static Uint32 last_frame_and_command_update = 0;
SDL_Thread *network_thread;
queue_t *message_queue;
#ifndef WINDOWS
SDL_EventState(SDL_SYSWMEVENT,SDL_ENABLE);
#endif
queue_initialise(&message_queue);
network_thread_data[0] = message_queue;
network_thread_data[1] = &done;
network_thread = SDL_CreateThread(get_message_from_server, network_thread_data);
/* Loop until done. */
while( !done )
{
SDL_Event event;
// handle SDL events
in_main_event_loop = 1;
while( SDL_PollEvent( &event ) )
{
done = HandleEvent(&event);
}
in_main_event_loop = 0;
//advance the clock
cur_time = SDL_GetTicks();
//check for network data
if(!queue_isempty(message_queue)) {
message_t *message;
while((message = queue_pop(message_queue)) != NULL)
{
process_message_from_server(message->data, message->length);
free(message->data);
free(message);
}
}
#ifdef OLC
olc_process();
#endif //OLC
my_tcp_flush(my_socket); // make sure the tcp output buffer is set
if (have_a_map && cur_time > last_frame_and_command_update + 60) {
LOCK_ACTORS_LISTS();
next_command();
UNLOCK_ACTORS_LISTS();
move_to_next_frame();
last_frame_and_command_update = cur_time;
}
while (cur_time > next_second_time && real_game_second < 59)
{
real_game_second += 1;
new_second();
next_second_time += 1000;
}
#ifdef NEW_SOUND
weather_sound_control();
#endif //NEW_SOUND
if(!limit_fps || (cur_time-last_time && 1000/(cur_time-last_time) <= limit_fps))
{
weather_update();
animate_actors();
//draw everything
draw_scene();
last_time=cur_time;
}
else {
SDL_Delay(1);//give up timeslice for anyone else
}
#ifdef TIMER_CHECK
//Check the timers to make sure that they are all still alive...
check_timers();
#endif
//cache handling
if(cache_system)cache_system_maint();
//see if we need to exit
if(exit_now) {
done = 1;
break;
}
}
if(!done) {
done = 1;
}
LOG_INFO("Client closed");
SDL_WaitThread(network_thread,&done);
queue_destroy(message_queue);
if(pm_log.ppl)free_pm_log();
//save all local data
save_local_data(NULL, 0);
#ifdef PAWN
cleanup_pawn ();
#endif
#ifdef NEW_SOUND
destroy_sound(); // Cleans up physical elements of the sound system and the streams thread
clear_sound_data(); // Cleans up the config data
#endif // NEW_SOUND
ec_destroy_all_effects();
if (have_a_map)
{
destroy_map();
free_buffers();
}
unload_questlog();
save_item_lists();
free_emotes();
free_actor_defs();
free_books();
free_vars();
cleanup_rules();
save_exploration_map();
cleanup_counters();
cleanup_chan_names();
cleanup_hud();
SDL_RemoveTimer(draw_scene_timer);
SDL_RemoveTimer(misc_timer);
end_particles ();
free_bbox_tree(main_bbox_tree);
main_bbox_tree = NULL;
free_astro_buffer();
free_translations();
free_skybox();
/* Destroy our GL context, etc. */
SDL_QuitSubSystem(SDL_INIT_AUDIO);
SDL_QuitSubSystem(SDL_INIT_TIMER);
/*#ifdef WINDOWS
// attempt to restart if requested
if(restart_required > 0){
LOG_INFO("Restarting %s", win_command_line);
SDL_CreateThread(system, win_command_line);
}
#endif //WINDOWS
*/
#ifdef NEW_SOUND
final_sound_exit();
#endif
#ifdef CUSTOM_UPDATE
stopp_custom_update();
#endif /* CUSTOM_UPDATE */
clear_zip_archives();
destroy_tcp_out_mutex();
if (use_frame_buffer) free_reflection_framebuffer();
printf("doing SDL_Quit\n");
fflush(stderr);
SDL_Quit( );
printf("done SDL_Quit\n");
fflush(stderr);
cleanup_mem();
xmlCleanupParser();
FreeXML();
exit_logging();
return(0);
}
int main(int argc, char **argv) {
if (argc == 1) {
fprintf(stderr, "You need to supply a binary as an argument e.g ./zdb <bin>");
exit(-1);
}
const char *path = argv[1];
const char *name = strrchr(path, '/');
if (name) {
name += 1;
} else {
name = path;
}
pid_t pid;
switch(pid = fork())
{
// error
case -1:
{
perror("fork()");
exit(-1);
}
// this is our child
case 0:
{
ptrace(PTRACE_TRACEME, 1337, NULL);
execl(path, name, NULL);
perror("execl()");
exit(-1);
}
}
int status;
long opcode[4];
long previous_ip;
wait(&status);
while(1)
{
if(WIFEXITED(status) || (WIFSIGNALED(status) && WTERMSIG(status) == SIGKILL))
{
printf("terminated");
exit(0);
}
if(WIFSTOPPED(status))
{
long rip = ptrace(PTRACE_PEEKUSER, pid, 8 * RIP, NULL)-1;
printf("Instruction stopped at: 0x%lx\n", rip);
}
/* read our user's command in */
zdb_command command = next_command();
switch(command.instruction) {
case NEXT:
{
long ip = ptrace(PTRACE_PEEKUSER, pid, 8 * RIP, NULL);
if(previous_ip)
{
long opcode_len = ip - previous_ip;
if(opcode_len > 0 && opcode_len < 16)
print_instruction(&opcode, opcode_len);
}
opcode[0] = ptrace(PTRACE_PEEKDATA, pid, ip, NULL);
opcode[1] = ptrace(PTRACE_PEEKDATA, pid, ip + sizeof(long), NULL);
previous_ip = ip;
ptrace(PTRACE_SINGLESTEP, pid, NULL, NULL);
wait(&status);
break;
}
case DUMP:
dump_registers(pid);
break;
case HEXDUMP:
{
long addr;
unsigned int size;
sscanf(command.args, "%lx %u", &addr, &size);
hexdump_region(addr, size, pid, true);
break;
}
case STACK_TRACE:
dump_stack_trace(pid);
break;
case QUIT:
{
printf("quitting zdb");
exit(0);
}
default:
fprintf(stderr, "invalid or unknown command\n");
}
}
}
int test(betree<uint64_t, std::string> &b,
uint64_t nops,
uint64_t number_of_distinct_keys,
FILE *script_input,
FILE *script_output)
{
std::map<uint64_t, std::string> reference;
for (unsigned int i = 0; i < nops; i++) {
int op;
uint64_t t;
if (script_input) {
int r = next_command(script_input, &op, &t);
if (r == EOF)
exit(0);
else if (r < 0)
exit(4);
} else {
op = rand() % 7;
t = rand() % number_of_distinct_keys;
}
switch (op) {
case 0: // insert
if (script_output)
fprintf(script_output, "Inserting %lu\n", t);
b.insert(t, std::to_string(t) + ":");
reference[t] = std::to_string(t) + ":";
break;
case 1: // update
if (script_output)
fprintf(script_output, "Updating %lu\n", t);
b.update(t, std::to_string(t) + ":");
if (reference.count(t) > 0)
reference[t] += std::to_string(t) + ":";
else
reference[t] = std::to_string(t) + ":";
break;
case 2: // delete
if (script_output)
fprintf(script_output, "Deleting %lu\n", t);
b.erase(t);
reference.erase(t);
break;
case 3: // query
try {
std::string bval = b.query(t);
assert(reference.count(t) > 0);
std::string rval = reference[t];
assert(bval == rval);
if (script_output)
fprintf(script_output, "Query %lu -> %s\n", t, bval.c_str());
} catch (std::out_of_range e) {
if (script_output)
fprintf(script_output, "Query %lu -> DNE\n", t);
assert(reference.count(t) == 0);
}
break;
case 4: // full scan
{
if (script_output)
fprintf(script_output, "Full_scan 0\n");
auto betit = b.begin();
auto refit = reference.begin();
do_scan(betit, refit, b, reference);
}
break;
case 5: // lower-bound scan
{
if (script_output)
fprintf(script_output, "Lower_bound_scan %lu\n", t);
auto betit = b.lower_bound(t);
auto refit = reference.lower_bound(t);
do_scan(betit, refit, b, reference);
}
break;
case 6: // scan
{
if (script_output)
fprintf(script_output, "Upper_bound_scan %lu\n", t);
auto betit = b.upper_bound(t);
auto refit = reference.upper_bound(t);
do_scan(betit, refit, b, reference);
}
break;
default:
abort();
}
}
std::cout << "Test PASSED" << std::endl;
return 0;
}
