int16
command_run (void)
{
  int8 *entry_point;
  void
  (*f) (void);

  entry_point = elf_load (xmodem_recv_buffer_start_address);
  if (!entry_point)
    {
      put_string ("run error!\n");
    }
  else
    {
      put_string ("starting from entry point:");
      put_hex ((uint32) entry_point, 6);
      put_string ("\n");
      put_string ("\n");
      f = (void
      (*) (void)) entry_point;
      f ();
    }
  return 0;
}

static void show_utf8(struct membuffer *b, const char *text, const char *pre, const char *post, int is_attribute)
{
    int len;
    char *cleaned;

    if (!text)
        return;
    /* remove leading and trailing space */
    /* We need to combine isascii() with isspace(),
     * because we can only trust isspace() with 7-bit ascii,
     * on windows for example */
    while (isascii(*text) && isspace(*text))
        text++;
    len = strlen(text);
    if (!len)
        return;
    while (len && isascii(text[len - 1]) && isspace(text[len - 1]))
        len--;
    cleaned = strndup(text, len);
    put_string(b, pre);
    quote(b, cleaned, is_attribute);
    put_string(b, post);
    free(cleaned);
}

// RTC alarm setup time
static void rtc_alarm_time(void) {
    char flag;
    char buffer[9];
    int temp, temp_time;
    util_clear_screen();
    // setup alarm second
    put_string("en alrm sec(y/n): ");
    flag = get_char();
    if (flag == 'y') {
        temp_time |= AT91C_RTC_SECEN;
        util_clear_screen();
        // update seconds
        put_string("set sec: ");
        get_string(buffer, 2, 1);
        temp = util_hex_to_int(buffer);
        if (temp >= 0x00 && temp <= 0x59) {
            temp_time |= temp & AT91C_RTC_SEC;
        }
        util_clear_screen();
    }
    // setup alarm minute
    put_string("en alrm min(y/n): ");
    flag = get_char();
    if (flag == 'y') {
        temp_time |= AT91C_RTC_MINEN;
        util_clear_screen();
        // update minutes
        put_string("set min: ");
        get_string(buffer, 2, 1);
        temp = util_hex_to_int(buffer);
        if (temp >= 0x00 && temp <= 0x59) {
            temp_time |= (temp << 8) & AT91C_RTC_MIN;
        }
        util_clear_screen();
    }
    // setup alarm minute
    put_string("en alrm hour(y/n): ");
    flag = get_char();
    if (flag == 'y') {
        temp_time |= AT91C_RTC_HOUREN;
        util_clear_screen();
        // update hours
        put_string("set hour: ");
        get_string(buffer, 2, 1);
        temp = util_hex_to_int(buffer);
        if (temp >= 0x00 && temp <= 0x23) {
            temp_time |= (temp << 16) & AT91C_RTC_HOUR;
        }
        util_clear_screen();
    }
    if (temp_time & AT91C_RTC_SECEN) {
        AT91C_BASE_RTC->RTC_TIMALR = temp_time;
        AT91C_BASE_RTC->RTC_IER |= AT91C_RTC_ALARM;
    }
}

init_fat(){
	/* enable everdrive card */
	clearFATBuffers();
	ed_begin();
	put_string("Initialise", 0, 1);
	everdrive_error = disk_init();
	put_number(everdrive_error, 3, 0, 2);
	everdrive_error = getMBR(0);
	put_number(everdrive_error, 3, 4, 2);
	everdrive_error = getFATVol();
	put_number(everdrive_error, 3, 8, 2);
	everdrive_error = getFATFS();
	put_number(everdrive_error, 3, 12, 2);
	/* NOTE: You should normally check that each call to the above 4 functions
	has returned correctly before proceeding! */
}

static int put_dynimport_decl(asymbol * sym, void *arg)
{
  char dynimport_decl[1024];
  const char *func_name = sym->name;
  int fd = (int)arg;

  /* Put the declaration for the dynamic info structure */
  if (func_name)
    {
      sprintf(dynimport_decl, dynimport_decl_format,
              MKINFODECLARGS(func_name, counter));
      put_string(fd, dynimport_decl);
      counter++;
    }
  return 0;
}

 void
 RTMPSession::sendCreateStream()
 {
     RTMPChunk_0 metadata = {{0}};
     metadata.msg_stream_id = kControlChannelStreamId;
     metadata.msg_type_id = RTMP_PT_INVOKE;
     std::vector<uint8_t> buff;
     put_string(buff, "createStream");
     m_createStreamInvoke = ++m_numberOfInvokes;
     m_trackedCommands[m_numberOfInvokes] = "createStream";
     put_double(buff, m_createStreamInvoke);
     put_byte(buff, kAMFNull);
     metadata.msg_length.data = static_cast<int>( buff.size() );
     
     sendPacket(&buff[0], buff.size(), metadata);
 }

// system timer handler
extern void st_handler(void) {
    int status = AT91C_BASE_ST->ST_SR & AT91C_BASE_ST->ST_IMR;
    // handler of pit
    if (status & AT91C_ST_PITS) {
        AT91C_BASE_PIOB->PIO_ODSR ^= AT91C_PIO_PB0;
    }
    // handler of rtt - rttinc
    if (status & AT91C_ST_RTTINC) {
        AT91C_BASE_PIOB->PIO_ODSR ^= AT91C_PIO_PB27;
    }
    // handler of rtt - alms
    if (status & AT91C_ST_ALMS) {
        put_string("Simple message\n");
        AT91C_BASE_ST->ST_RTAR += 40;
    }
}

int
main (int argc, char **argv)
{
  char *command_line;
  header the_header;
  long name_length;
  char *mail_program_name;
  char buf[BUFLEN + 1];
  register int size;
  FILE *the_pipe;

  extern char *getenv (const char *);

  mail_program_name = getenv ("FAKEMAILER");
  if (!(mail_program_name && *mail_program_name))
    mail_program_name = MAIL_PROGRAM_NAME;
  name_length = strlen (mail_program_name);

  my_name = MY_NAME;
  the_streams = ((stream_list) NULL);
  the_date = ((char *) NULL);
  the_user = ((char *) NULL);

  the_header = read_header ();
  command_line = alloc_string (name_length + args_size (the_header));
  strcpy (command_line, mail_program_name);
  parse_header (the_header, &command_line[name_length]);

  the_pipe = popen (command_line, "w");
  if (the_pipe == ((FILE *) NULL))
    fatal ("cannot open pipe to real mailer");

  add_a_stream (the_pipe, pclose);

  write_header (the_header);

  /* Dump the message itself */

  while (!feof (stdin))
    {
      size = fread (buf, 1, BUFLEN, stdin);
      buf[size] = '\0';
      put_string (buf);
    }

  exit (close_the_streams ());
}

int nice_copy(char *title, char *source, char *dest)
{
  int x1=0,y1=0,x2=79,y2=25;
  bar(x1,y1+1,x2,y2,176,0x01);
  put_title(title);

  box(x1,(y1+y2)/2-1,x2,(y1+y2)/2+3,0x17);
  bar(x1+1,(y1+y2)/2,x2-1,(y1+y2)/2+2,' ',0x17);
  
  char msg[100];
  sprintf(msg,"Copying %s -> %s",source,dest);
  put_string(x1+1,(y1+y2)/2,msg,0x17);
  bar(x1+1,(y1+y2)/2+2,x2-1,(y1+y2)/2+2,176,0x17);

  char *buffer=(char *)jmalloc(0xf000,"read buf");
  if (!buffer) return 0;
  FILE *out=fopen(dest,"wb");
  if (!out) { jfree(buffer) ; return 0; }
  FILE *in=fopen(source,"rb");
  if (!in) { jfree(buffer); fclose(out); unlink(dest); return 0; }

  fseek(in,0,SEEK_END);
  long size=ftell(in);
  fseek(in,0,SEEK_SET);
  int osize=size;
  while (size)
  {
    long tr=fread(buffer,1,0xf000,in);
    bar(x1+1,(y1+y2)/2+2,x1+1+(x2-x1)*(osize-size-tr)/osize,(y1+y2)/2+2,178,0x17);

    if (fwrite(buffer,1,tr,out)!=tr)
    {
      fclose(out);
      fclose(in);
      unlink(dest);
      jfree(buffer);
      return 0;
    }
    size-=tr;
    
  }
  fclose(in);
  fclose(out);
  jfree(buffer);
  cls();
  return 1;
}

void syslinux_execute(void)
{
	char *device, *diskdevice;
	char *bootimages;
	int fd;

	if (strcmp(hashmapGetPrintf(ictx.opts, "none", BASE_BOOTLOADER),
				"syslinux"))
		return;

	pr_info("Writing MBR");
        diskdevice = xasprintf("/dev/block/%s",
			hashmapGetPrintf(ictx.opts, NULL, BASE_INSTALL_DISK));
	dd(SYSLINUX_MBR, diskdevice);
        free(diskdevice);

	/* SYSLINUX complains if this isn't done */
	chmod("/tmp", 01777);

	bootimages = hashmapGetPrintf(ictx.opts, NULL, BASE_BOOT_LIST);
	device = hashmapGetPrintf(ictx.opts, NULL, "partition.bootloader:device");
	pr_info("Installing ldlinux.sys onto %s", device);
	do_install_syslinux(device);

	/* In case we die() before we are finished */
	signal(SIGABRT, sighandler);
	mount_partition_device(device, "vfat", BOOTLOADER_PATH);

	pr_info("Copying syslinux support files");
	copy_file(IMAGES_PATH "vesamenu.c32", BOOTLOADER_PATH "vesamenu.c32");
	copy_file(IMAGES_PATH "android.c32", BOOTLOADER_PATH "android.c32");

	pr_info("Constructing syslinux.cfg");
	/* Put the initial template stuff in */
	copy_file(SYSLINUX_CFG_TEM_FN, SYSLINUX_CFG_FN);
	fd = xopen(SYSLINUX_CFG_FN, O_WRONLY | O_APPEND);
	put_string(fd, "menu androidcommand %s\n",
		hashmapGetPrintf(ictx.opts, NULL, "partition.misc:index"));
	string_list_iterate(bootimages, bootimage_cb, &fd);

	xclose(fd);
	umount(BOOTLOADER_PATH);
	rmdir(BOOTLOADER_PATH);
	signal(SIGABRT, SIG_DFL);
	pr_info("SYSLINUX installation complete");
}

/*! \fn       int32 print_can_frame(void)
*
*  \brief     打印CAN帧
*
*  \param     无
*
*  \exception 无
*
*  \return    EXIT_FAILURE：失败；EXIT_SUCCESS：成功
*/
int32 print_can_frame(void)
{
    int32 lRet = EXIT_SUCCESS;

    if(s_unCanSegMsgReadIndex != s_unCanSegMsgWriteIndex)
    {
        put_string(" ");
        lRet = print_protocol_frame(&(s_aucCanSegMsgBuf[s_unCanSegMsgReadIndex][0]));
        s_unCanSegMsgReadIndex++;
        if(CAN_MSG_BUF_SIZE <= s_unCanSegMsgReadIndex)
        {
            s_unCanSegMsgReadIndex = 0;
        }
    }

    return lRet;
}

static int put_dynimport_array(asymbol * sym, void *arg)
{
  char dynimport_array[1024];
  const char *func_name = sym->name;
  int fd = (int)arg;

  /* Create the dynimport_array */

  if (func_name)
    {
      sprintf(dynimport_array, dynimport_array_format,
              MKINFOARGS(func_name, counter));
      put_string(fd, dynimport_array);
      counter++;
    }
  return 0;
}

static int put_import_name(asymbol * sym, void *arg)
{
  char import_name[512];
  const char *func_name = sym->name;
  int fd = (int)arg;

  /* Create the import_name */

  if (func_name)
    {
      sprintf(import_name, import_name_strtab_format,
              MKIMPSTRTABARG(func_name, counter));
      put_string(fd, import_name);
      counter++;
    }
  return 0;
}

/*
 * We're outputting utf8 in xml.
 * We need to quote the characters <, >, &.
 *
 * Technically I don't think we'd necessarily need to quote the control
 * characters, but at least libxml2 doesn't like them. It doesn't even
 * allow them quoted. So we just skip them and replace them with '?'.
 *
 * If we do this for attributes, we need to quote the quotes we use too.
 */
static void quote(struct membuffer *b, const char *text, int is_attribute)
{
	const char *p = text;

	for (;;) {
		const char *escape;

		switch (*p++) {
		default:
			continue;
		case 0:
			escape = NULL;
			break;
		case 1 ... 8:
		case 11:
		case 12:
		case 14 ... 31:
			escape = "?";
			break;
		case '<':
			escape = "&lt;";
			break;
		case '>':
			escape = "&gt;";
			break;
		case '&':
			escape = "&amp;";
			break;
		case '\'':
			if (!is_attribute)
				continue;
			escape = "&apos;";
			break;
		case '\"':
			if (!is_attribute)
				continue;
			escape = "&quot;";
			break;
		}
		put_bytes(b, text, (p - text - 1));
		if (!escape)
			break;
		put_string(b, escape);
		text = p;
	}
}

static ipc_msg_hdr *create_hdr(uint32_t op, size_t *len, char **data_start, int reuse_socket)
    {
    char *msg = NULL;
    ipc_msg_hdr *hdr;
    int datalen;
#if !defined(USE_TCP_LOOPBACK)
    char ctrl_path[256];
#endif

    if (!reuse_socket)
        {
#if defined(USE_TCP_LOOPBACK)
		*len += 2;  // Allocate space for two-byte port number
#else
		struct timeval time;
		if (gettimeofday(&time, NULL) < 0) return NULL;
		sprintf(ctrl_path, "%s%d-%.3lx-%.6lu", CTL_PATH_PREFIX, (int)getpid(),
			(unsigned long)(time.tv_sec & 0xFFF), (unsigned long)(time.tv_usec));
        *len += strlen(ctrl_path) + 1;
#endif
        }

    datalen = (int) *len;
    *len += sizeof(ipc_msg_hdr);

    // write message to buffer
    msg = malloc(*len);
    if (!msg) return NULL;

    bzero(msg, *len);
    hdr = (void *)msg;
    hdr->datalen = datalen;
    hdr->version = VERSION;
    hdr->op = op;
    if (reuse_socket) hdr->flags |= IPC_FLAGS_REUSE_SOCKET;
    *data_start = msg + sizeof(ipc_msg_hdr);
#if defined(USE_TCP_LOOPBACK)
	// Put dummy data in for the port, since we don't know what
	// it is yet.  The data will get filled in before we
	// send the message. This happens in deliver_request().
	if (!reuse_socket)  put_short(0, data_start);
#else
    if (!reuse_socket)  put_string(ctrl_path, data_start);
#endif
    return hdr;
    }

// run another code
static void run_kernel(void) {
    unsigned read_size;
    unsigned boot_args[AT45_PAGE_SIZE / 4];
    kernel_t kernel = (kernel_t) LINUX_BASE_ADDRESS;
    unsigned *tags = (unsigned *) LINUX_TAGS_ADDRESS;
    unsigned *sz, len;
    const char *cmdline = "mem=128M root=/dev/sda1 rootwait ro";

    /*if (!at45_read(BOOT_2_ARGS_OFFSET, boot_args, AT45_PAGE_SIZE)) {
        read_size = boot_args[0];
        util_printf("Read 0x%x bytes\n", read_size);
        if (read_size > 0 && read_size < (AT45DB642D_SIZE - 4)) {
            if (!at45_read(LINUX_OFFSET, (unsigned *)LINUX_BASE_ADDRESS, read_size)) {*/
    put_string("Read success\nConfiguring\n");
    /* atag_core */
    *tags++ = 5;
    *tags++ = 0x54410001;
    *tags++ = 1;
    *tags++ = 4096;
    *tags++ = 0;

    /* atag_mem */
    *tags++ = 4;
    *tags++ = 0x54410002;
    *tags++ = SDRAM_BASE_ADDRESS;
    *tags++ = SDRAM_SIZE;

    /* atag_cmdline */
    sz = tags++;
    *tags++ = 0x54410009;
    len = cmdcpy(tags, cmdline);
    *sz = 2 + len;
    tags += len;

    /* atag_none */
    *tags++ = 0;
    *tags++ = 0;

    util_printf("Jump to the kernel image\n\n");

    kernel(0, MACHINE_ID, (void*) LINUX_TAGS_ADDRESS);
    /*}
    }
    }*/
}

static void
put_stringv (GDataOutputStream *out,
	     char **strv)
{
  int len, i;

  len = g_strv_length (strv);
  if (len > G_MAXUINT16)
    {
      g_warning ("GFileInfo stringv to large, (%d elements)\n", (int)len);
      len = 0;
    }

  g_data_output_stream_put_uint16 (out, len,
				   NULL, NULL);
  for (i = 0; i < len; i++)
    put_string (out, strv[i]);
}

static ER
vprintf (B *fmt, VP arg0)
{
  VP *ap;

  for (ap = (VP *)arg0; *fmt != '\0'; fmt++)
    {
      if ((*fmt) == '%')
	{
	  ++fmt;
	  switch (*fmt)
	    {
	    case 's':
	      put_string (*(B **)ap, log_port);
	      INC (ap, B *);
	      break;

	    case 'd':
	      if ((W)*ap < 0)
		{
		  ((W)*ap) = -((W)*ap);
		  putc ('-', log_port);
		}
	      print_digit ((W)*ap, 10);
	      INC (ap, W);
	      break;

	    case 'x':
	      print_digit ((UW)*ap, 16);
	      INC (ap, W);
	      break;

	    default:
	      putc ('%', log_port);
	      break;
	    }
	}
      else
	{
	  putc (*fmt, log_port);
	}
    }
}

void RefreshMainAux(int sel, int row)
{
	set_font_pal(sel == 7 ? 15 : 14);
	put_string("Horizontal Stripes", HPOS, row++);
	set_font_pal(sel == 8 ? 15 : 14);
	put_string("Checkerboard", HPOS, row++);
	set_font_pal(sel == 9 ? 15 : 14);
	put_string("Backlit Zone Test", HPOS, row++);
	set_font_pal(sel == 10 ? 15 : 14);
	put_string("Sound Test", HPOS, row++);
	set_font_pal(sel == 11 ? 15 : 14);
	put_string("Audio Sync Test", HPOS, row++);
	
	set_font_pal(sel == 12 ? 15 : 14);
	put_string("Video Options", HPOS, ++row);
	
	set_font_pal(sel == 13 ? 15 : 14);
	put_string("Help", HPOS, ++row);
	set_font_pal(sel == 14 ? 15 : 14);
	put_string("Credits", HPOS, ++row);
}

void writeMarkers(struct membuffer *b, const bool selected_only)
{
	int i, dive_no = 0;
	struct dive *dive;
	char pre[1000], post[1000];

	for_each_dive (i, dive) {
		if (selected_only) {
			if (!dive->selected)
				continue;
		}
		struct dive_site *ds = get_dive_site_for_dive(dive);
		if (!ds || !dive_site_has_gps_location(ds))
			continue;
		put_degrees(b, ds->latitude, "temp = new google.maps.Marker({position: new google.maps.LatLng(", "");
		put_degrees(b, ds->longitude, ",", ")});\n");
		put_string(b, "markers.push(temp);\ntempinfowindow = new google.maps.InfoWindow({content: '<div id=\"content\">'+'<div id=\"siteNotice\">'+'</div>'+'<div id=\"bodyContent\">");
		snprintf(pre, sizeof(pre), "<p>%s ", translate("gettextFromC", "Date:"));
		put_HTML_date(b, dive, pre, "</p>");
		snprintf(pre, sizeof(pre), "<p>%s ", translate("gettextFromC", "Time:"));
		put_HTML_time(b, dive, pre, "</p>");
		snprintf(pre, sizeof(pre), "<p>%s ", translate("gettextFromC", "Duration:"));
		snprintf(post, sizeof(post), " %s</p>", translate("gettextFromC", "min"));
		put_duration(b, dive->duration, pre, post);
		put_string(b, "<p> ");
		put_HTML_quoted(b, translate("gettextFromC", "Max. depth:"));
		put_HTML_depth(b, dive, " ", "</p>");
		put_string(b, "<p> ");
		put_HTML_quoted(b, translate("gettextFromC", "Air temp.:"));
		put_HTML_airtemp(b, dive, " ", "</p>");
		put_string(b, "<p> ");
		put_HTML_quoted(b, translate("gettextFromC", "Water temp.:"));
		put_HTML_watertemp(b, dive, " ", "</p>");
		snprintf(pre, sizeof(pre), "<p>%s <b>", translate("gettextFromC", "Location:"));
		put_string(b, pre);
		put_HTML_quoted(b, get_dive_location(dive));
		put_string(b, "</b></p>");
		snprintf(pre, sizeof(pre), "<p> %s ", translate("gettextFromC", "Notes:"));
		put_HTML_notes(b, dive, pre, " </p>");
		put_string(b, "</p>'+'</div>'+'</div>'});\ninfowindows.push(tempinfowindow);\n");
		put_format(b, "google.maps.event.addListener(markers[%d], 'mouseover', function() {\ninfowindows[%d].open(map,markers[%d]);}", dive_no, dive_no, dive_no);
		put_format(b, ");google.maps.event.addListener(markers[%d], 'mouseout', function() {\ninfowindows[%d].close();});\n", dive_no, dive_no);
		dive_no++;
	}
}