int put_avr_firmware(char *firmware_filename)
{
    int r;
    
    r = do_command(CMD_AVR_I2CRST, bigbuf, sizeof(bigbuf));
    if (r < 0) {
	printf("do_twiboot: CMD_AVR_I2CRST: failed, but may continue...\n");
	/* no return, because in bootloader mode, 
	 AVR doesn't need I2C reset */
	/* return -1; */
    }
    usleep(100*1000L);

    if (rpi_rev == 1) {
	r = do_command(CMD_TWIBOOT_I2CREV1, bigbuf, sizeof(bigbuf));
    }
    else if (rpi_rev == 2) {
	r = do_command(CMD_TWIBOOT_I2CREV2, bigbuf, sizeof(bigbuf));
    }
    else {
	printf("put_avr_firmware: rpi_rev incorrectly, or not set\n");
    }
    
    /* DO STUFF TO CHECK twiboot SUCCESS/FAILURE FROM bigbuf*/
    
    return r;
}

int main(int argc, char *argv[])
{
	ProgramMode mode;
	LHAOptions options;

#ifdef TEST_BUILD
	// When running tests, give output to stdout in binary mode;
	// on Windows, this gives the expected output (which was
	// constructed for Unix):

	lha_arch_set_binary(stdout);
#endif

	// Parse the command line options and run command.
	// As a shortcut, a single argument can be provided to list the
	// contents of an archive ("lha foo.lzh" == "lha l foo.lzh").

	init_options(&options);

	if (argc >= 3 && parse_command_line(argv[1], &mode, &options)) {
		return !do_command(mode, argv[2], &options,
		                   argv + 3, argc - 3);
	} else if (argc == 2) {
		return !do_command(MODE_LIST, argv[1], &options, NULL, 0);
	} else {
		help_page(argv[0]);
		return 0;
	}
}

void test3(int fd) {
  /* encrypt */
  do_command(fd, (unsigned char*) "CMDencrypt#", "123456test");

  /* decrypt */
  do_command(fd, (unsigned char*) "CMDdecrypt#", "abcdwt6'16");
}

void execute(WINDOW* w, ToxWindow *self, Tox *m, char *cmd, int mode)
{
    if (string_is_empty(cmd))
        return;

    char args[MAX_NUM_ARGS][MAX_STR_SIZE] = {0};
    int num_args = parse_command(w, cmd, args);

    if (num_args == -1)
        return;

    /* Try to match input command to command functions. If non-global command mode is specified, 
       try specified mode's commands first, then upon failure try global commands. 

       Note: Global commands must come last in case of duplicate command names */
    switch (mode) {
    case CHAT_COMMAND_MODE:
        if (do_command(w, self, m, num_args, CHAT_NUM_COMMANDS, chat_commands, args) == 0)
            return;
        break;

    case GROUPCHAT_COMMAND_MODE:
        break;
    }

    if (do_command(w, self, m, num_args, GLOBAL_NUM_COMMANDS, global_commands, args) == 0)
        return;

    wprintw(w, "Invalid command.\n");
}

void execute(WINDOW *w, ToxWindow *self, Tox *m, const char *input, int mode)
{
    if (string_is_empty(input))
        return;

    char args[MAX_NUM_ARGS][MAX_STR_SIZE];
    int num_args = parse_command(w, self, input, args);

    if (num_args == -1)
        return;

    /* Try to match input command to command functions. If non-global command mode is specified,
       try specified mode's commands first, then upon failure try global commands.

       Note: Global commands must come last in case of duplicate command names */
    switch (mode) {
        case CHAT_COMMAND_MODE:
            if (do_command(w, self, m, num_args, chat_commands, args) == 0)
                return;

            break;

        case GROUPCHAT_COMMAND_MODE:
            break;
    }

    if (do_command(w, self, m, num_args, global_commands, args) == 0)
        return;

    line_info_add(self, NULL, NULL, NULL, SYS_MSG, 0, 0, "Invalid command.");
}

static int timeout_func(gpointer data)
{
	int pos;
	gboolean playing;
	static char *previous_file = NULL;
	static gboolean cmd_after_already_run = FALSE;
	char *current_file;

	GDK_THREADS_ENTER();

	playing = xmms_remote_is_playing(sc_gp.xmms_session);
	pos = xmms_remote_get_playlist_pos(sc_gp.xmms_session);
	current_file = xmms_remote_get_playlist_file(sc_gp.xmms_session, pos);
	
	if ((pos != previous_song ||
	     (!previous_file && current_file) ||
	     (previous_file && !current_file) ||
	     (previous_file && current_file &&
	      strcmp(previous_file, current_file))) &&
	    xmms_remote_get_output_time(sc_gp.xmms_session) > 0)
	{
		do_command(cmd_line, current_file, pos);
		g_free(previous_file);
		previous_file = g_strdup(current_file);
		previous_song = pos;
		cmd_after_already_run = FALSE;
	}
	if (!cmd_after_already_run &&
	    ((xmms_remote_get_playlist_time(sc_gp.xmms_session,pos) -
	      xmms_remote_get_output_time(sc_gp.xmms_session)) < 100))
	{
		do_command(cmd_line_after, current_file, pos);
		cmd_after_already_run = TRUE;
	}

	if (playing)
	{
		int playlist_length = xmms_remote_get_playlist_length(sc_gp.xmms_session);
		if (pos + 1 == playlist_length)
			possible_pl_end = TRUE;
		else
			possible_pl_end = FALSE;
	}
	else if (possible_pl_end)
	{
		if (pos == 0)
			do_command(cmd_line_end, current_file, pos);
		possible_pl_end = FALSE;
		g_free(previous_file);
		previous_file = NULL;
	}

	g_free(current_file);
	current_file = NULL;

	GDK_THREADS_LEAVE();

	return TRUE;
}

void upsdrv_shutdown(void)
{
	char reply[8];
	
	if(!(do_command(cmd_setOutOffMode, reply, 8) != -1) &&
	(do_command(cmd_setOutOffDelay, reply, 8) != -1) &&
	(do_command(cmd_sysLoadKey, reply, 6) != -1) &&
	(do_command(cmd_shutdown, reply, 8) != -1))
	upslogx(LOG_ERR, "Failed to shutdown UPS");
}

static void set_identification(const char *val) {
	char response[MAX_RESPONSE_LENGTH];

	if (do_command(POLL, IDENTIFICATION, "", response) < 0)
		return;
	if (strcmp(val, response)) {
		strncpy(response, val, MAX_RESPONSE_LENGTH);
		response[MAX_RESPONSE_LENGTH - 1] = '\0';
		do_command(SET, IDENTIFICATION, response, NULL);
	}
}

void		do_reverse_command(t_app *app, unsigned char command)
{
	if (command >= RA && command <= RR)
		do_command(app, command + 3);
	else if (command >= RRA && command <= RRR)
		do_command(app, command - 3);
	else if (command == PA)
		do_command(app, command + 1);
	else if (command == PB)
		do_command(app, command - 1);
	else
		do_command(app, command);
}

void run_commands(unsigned int num_command, const char commands_list[max_commands][max_command_length], int to_file)
{
    if(to_file)
    {
        FILE* f = fopen("/home/box/result.out", "w");
        if(f)
        {
            close(STDOUT_FILENO);
            dup2(f->_fileno, STDOUT_FILENO);
            fclose(f);
        }
    }

    if(num_command > 0)
    {
        int pfd[2];
        pipe(pfd);

        if(!fork())
        {
            // child
            close(STDOUT_FILENO);
            dup2(pfd[1], STDOUT_FILENO);

            close(pfd[1]);
            close(pfd[0]);

            run_commands(num_command-1, commands_list, 0);
        }
        else
        {
            // parent
            close(STDIN_FILENO);
            dup2(pfd[0], STDIN_FILENO);

            close(pfd[1]);
            close(pfd[0]);

            char params[2][max_command_length];
            parce_command(commands_list[num_command], params);
            do_command(params);
        }
    }
    else
    {
        char params[2][max_command_length];
        parce_command(commands_list[num_command], params);
        do_command(params);
    }
}

void upsdrv_shutdown(void)
{
	char parm[20];

	if (!init_comm())
		printf("Status failed.  Assuming it's on battery and trying a shutdown anyway.\n");
	auto_reboot(1);
	/* in case the power is on, tell it to automatically reboot.  if
	   it is off, this has no effect. */
	snprintf(parm, sizeof(parm), "%d", 1); /* delay before reboot, in minutes */
	do_command(SET, SHUTDOWN_RESTART, parm, NULL);
	snprintf(parm, sizeof(parm), "%d", 5); /* delay before shutdown, in seconds */
	do_command(SET, SHUTDOWN_ACTION, parm, NULL);
}

int get_avr_serial(char *sermem)
{
    int r;
    FILE *eepfile;
    
    r = do_command(CMD_AVR_QUIET R_EEPROM, bigbuf, sizeof(bigbuf));
    if (r < 0) {
	return -1;
    }
    
    if ((eepfile = fopen("eep.raw", "r")) == NULL) {
	printf("%s: open eep.raw file failed\n", __func__);
	return -2;
    }
    fseek(eepfile, 512-16, SEEK_SET);
    fread(sermem, 1, 16, eepfile);
    fclose(eepfile);
    sermem[16] = 0;

#if 0
    for (i = 0, p = serial_mem; i < 16; i++, p++) {
	if (i !=0 && (i % 8) == 0)   printf("\n");
	printf("%c 0x%02x ", isprint(*p) ? *p : '.', *p);
    }
    printf("\n");
#endif

    return 0;
}

static int				/* O - Status from cups-lpd */
remove_job(int  outfd,			/* I - Command file descriptor */
           int  infd,			/* I - Response file descriptor */
	   char *dest,			/* I - Destination */
	   char **args)			/* I - Arguments */
{
  int		i;			/* Looping var */
  char		command[1024];		/* Command buffer */

 /*
  * Send the "remove jobs" command...
  */

  snprintf(command, sizeof(command), "\005%s", dest);

  for (i = 0; args[i]; i ++)
  {
    strlcat(command, " ", sizeof(command));
    strlcat(command, args[i], sizeof(command));
  }

  strlcat(command, "\n", sizeof(command));

  return (do_command(outfd, infd, command));
}

int					main(int ac, char **av, char **env)
{
	char	*line2;
	t_e		e;

	(void)ac;
	(void)av;
	e.list = ft_env_cpy(env);
	signal(SIGQUIT, ft_signal);
	show_prompt(e.list);
	while (get_next_line(0, &(e.line)) == 1)
	{
		line2 = exange_tab_or_space(e.line);
		e.args = ft_strsplit(line2, ' ');
		if (e.args && e.args[0])
		{
			if (ft_strchr(e.args[0], '/'))
				exec_absolu(e.line, e.list);
			else
				do_command(&(e.list), e.line);
		}
		free(e.line);
		show_prompt(e.list);
		free_char_array(e.args);
	}
	ft_putchar('\n');
	return (0);
}

int main()
{
	int running = 1;
	character player;

	/* SET START --------------------------------*/
	room start; 
	strcpy(start.description , "Game Name. [goto] the bedroom to start.");
	/* SET START --------------------------------*/

	/* SET BEDROOM --------------------------------*/
	room bedroom = {"Bedroom", {"pencil", "towel", "backpack"}};
	strcpy(bedroom.entrance_msg, "You wake up.");
	/* SET BEDROOM --------------------------------*/

	player.current_room = start;

	while (running)
	{
		print_room_summary(player.current_room);
		char command[100];
		scanf("%[^\n]", command);
		do_command(command);

	}
	return 0;
}

void command_prompt(void *pvParameters)
{
	char buf[128];
	char *argv[20];
        char hint[] = USER_NAME "@" USER_NAME "-STM32:~$ ";

	fio_printf(1, "\rWelcome to FreeRTOS Shell\r\n");
	while(1){
		fio_printf(1, "%s", hint);
		fio_read(0, buf, 127);
	
		int n=parse_command(buf, argv);

		/* will return pointer to the command function */
		//if (*argv[0]=='\0')
		cmdfunc *fptr=do_command(argv[0]);
		if(fptr!=NULL)
			fptr(n, argv);
		else if (*argv[0]!='\0')
			fio_printf(2, "\r\n\"%s\" command not found.\r\n", argv[0]);
		else
			fio_printf(1, "\r\n");
	}

}

int			main(void)
{
	char	*line;
	char	*line2;
	t_list	*list;
	char	**args;

	list = ft_env_cpy();
	signal(SIGINT, ft_signal);
	show_prompt(list);
	while (get_next_line(0, &line) == 1)
	{
		line2 = exchange_tab_for_space(line);
		args = ft_strsplit(line2, ' ');
		if (args && args[0])
		{
			if (ft_strchr(args[0], '/'))
				exec_absolu(line, list);
			else
				do_command(&list, line);
		}
		free(line);
		show_prompt(list);
		free_char_array(args);
	}
	ft_putchar('\n');
	return (0);
}

static int do_client(void)
{
	int rv;

	rv = setup_config(CLIENT);
	if (rv < 0) {
		log_error("cannot read config");
		goto out;
	}

	switch (cl.op) {
	case CMD_LIST:
	case CMD_PEERS:
		rv = query_get_string_answer(cl.op);
		break;

	case CMD_GRANT:
	case CMD_REVOKE:
		rv = do_command(cl.op);
		break;
	}

out:
	return rv;
}

int main(int argc, char **argv) {
	parse_options(argc, argv);
	exec_info();

	while (1) {
		printf("> ");
		char command_line[1024];
		memset(command_line, 0, 1024);
		fgets(command_line, 1024, stdin);

		if (strlen(command_line) == 0 && feof(stdin)) {
			printf("\n");
			break;
		}

		//printf("command: %s\n", command_line);

		do_command(command_line);
	}

	int i;
	for (i = 0; i < files_count; i++) {
		file_delete(files[i]);
	}
	free(files);
	return 0;
}

/* Perform an imitation lseek operation on remote tape connection
   HANDLE.  Return the new file offset if successful, -1 if on error.  */
off_t
rmt_lseek__ (int handle, off_t offset, int whence)
{
  char command_buffer[COMMAND_BUFFER_SIZE];
  char operand_buffer[UINTMAX_STRSIZE_BOUND];
  uintmax_t u = offset < 0 ? - (uintmax_t) offset : (uintmax_t) offset;
  char *p = operand_buffer + sizeof operand_buffer;

  *--p = 0;
  do
    *--p = '0' + (int) (u % 10);
  while ((u /= 10) != 0);
  if (offset < 0)
    *--p = '-';

  switch (whence)
    {
    case SEEK_SET: whence = 0; break;
    case SEEK_CUR: whence = 1; break;
    case SEEK_END: whence = 2; break;
    default: abort ();
    }

  sprintf (command_buffer, "L%s\n%d\n", p, whence);

  if (do_command (handle, command_buffer) == -1)
    return -1;

  return get_status_off (handle);
}