int main(int argc, char *argv[])
{
	char buffer[MAX_PACKET_SIZE];
	static struct sockaddr_in addr;
	int rc, i, count;
	struct timeval t1, t2, dt;


	KICK(argc < 3, "incorrect usage\n"
	"Usage:\n"
	"./linphone_proxy <local_ip> <remote_ip>\n");
	local_ip = argv[1];
	remote_ip = argv[2];

	add_poll(&fds[0], STDIN_FILENO);

	proxy_to_linphone_socket = create_socket(SOCK_DGRAM, SIP_LINPHONE);
	init_sockaddr(&proxy_to_linphone_addr, "127.0.0.1", SIP_PORT);
	add_poll(&fds[1], proxy_to_linphone_socket);
	eprintf("created proxy_to_linphone SIP socket   SRC:localhost:%d - DST:localhost:%d\n",
			SIP_LINPHONE, SIP_PORT);

	proxy_to_proxy_socket = create_socket(SOCK_DGRAM, SIP_PROXY);
	init_sockaddr(&proxy_to_proxy_addr, remote_ip, SIP_PROXY);
	add_poll(&fds[2], proxy_to_proxy_socket);
	eprintf("created proxy_to_sip SIP socket        SRC:localhost:%d - DST:%s:%d\n",
			SIP_PROXY, remote_ip, SIP_PROXY);

	proxy_to_linphone_data_socket = create_socket(SOCK_DGRAM, DATA_LINPHONE);
	init_sockaddr(&proxy_to_linphone_data_addr, "127.0.0.1", DATA_PORT);
	add_poll(&fds[3], proxy_to_linphone_data_socket);
	eprintf("created proxy_to_linphone DATA socket  SRC:localhost:%d - DST:localhost:%d\n",
			DATA_LINPHONE, DATA_PORT);

	proxy_to_proxy_data_socket = create_socket(SOCK_DGRAM, DATA_PROXY);
	init_sockaddr(&proxy_to_proxy_data_addr, remote_ip, DATA_PROXY);
	add_poll(&fds[4], proxy_to_proxy_data_socket);
	eprintf("created proxy_to_proxy DATA socket     SRC:localhost:%d - DST:%s:%d\n",
			DATA_PROXY, remote_ip, DATA_PROXY);

	manager_socket = create_socket(SOCK_DGRAM, MANAGER_PORT);
	init_sockaddr(&manager_addr, "0.0.0.0", MANAGER_PORT);
	add_poll(&fds[5], manager_socket);
	eprintf("created manager socket                 SRC:localhost:%d - DST:0.0.0.0:0\n",
			MANAGER_PORT);

	while (1) {
		rc = poll(fds, NUM_FDS, -1);
		DIE(-1 == rc, "poll");

		for (i = 0; i < NUM_FDS; i++) {
			if (0 == fds[i].revents) {
				continue;
			}

			switch(i) {
			/* receive line from console */
			case 0:
				break;

			/* receive SIP packet from linphone */
			case 1:
				gettimeofday_safe(&t1);
				count = recv_msg(fds[i].fd, &proxy_to_linphone_addr, buffer);

				if (begins_with(buffer, "INVITE")) {
					copy_packet(&out_invite, buffer, count);
					//printf("captured INVITE packet:\n%s\n", out_invite.buffer);
				} else if (begins_with(buffer, "ACK")) {
					copy_packet(&out_ack, buffer, count);
					//printf("captured ACK packet:\n%s\n", out_ack.buffer);
				} else if (strstr(buffer, "200 OK") && strstr(buffer, "OPTIONS" )) {
					copy_packet(&out_op_ok, buffer, count);
					//printf("captured OPTIONS OK packet:\n%s\n", out_op_ok.buffer);
				}

				send_msg(proxy_to_proxy_socket, &proxy_to_proxy_addr, buffer, count);
				gettimeofday_safe(&t2);
				time_diff(&t1, &t2, &dt);
				printf("time case 1: %lu.%06lu\n", dt.tv_sec, dt.tv_usec);

				break;

			/* receive SIP packet from proxy */
			case 2:
				gettimeofday_safe(&t1);
				count = recv_msg(fds[i].fd, &addr, buffer);
				send_msg(proxy_to_linphone_socket, &proxy_to_linphone_addr, buffer, count);
				gettimeofday_safe(&t2);
				time_diff(&t1, &t2, &dt);
				printf("time case 2: %lu.%06lu\n", dt.tv_sec, dt.tv_usec);
				break;

			/* receive data packet from linphone */
			case 3:
				gettimeofday_safe(&t1);
				count = recv_msg(fds[i].fd, &proxy_to_linphone_data_addr, buffer);
				send_msg(proxy_to_proxy_data_socket, &proxy_to_proxy_data_addr, buffer, count);
				gettimeofday_safe(&t2);
				time_diff(&t1, &t2, &dt);
//.........这里部分代码省略.........

static void
usage(void)
{
	eprintf("usage: %s [name]\n", argv0);
}

int main(int argc, char **argv) {
	const char *addr = NULL;
	RCore *c, *c2;
	RDiff *d;
	ut8 *bufa, *bufb;
	int o, sza, szb, /*diffmode = 0,*/ delta = 0;
	int mode = MODE_DIFF;
	int diffops = 0;
	int threshold = -1;
	int gdiff_mode = 0;
	double sim;

	while ((o = getopt (argc, argv, "a:b:CDnpg:Ojrhcdsvxt:")) != -1) {
		switch (o) {
		case 'a':
			arch = optarg;
			break;
		case 'b':
			bits = atoi (optarg);
			break;
		case 'p':
			useva = false;
			break;
		case 'r':
			diffmode = 'r';
			break;
		case 'g':
			mode = MODE_GRAPH;
			addr = optarg;
			break;
		case 'c':
			showcount = 1;
			break;
		case 'C':
			mode = MODE_CODE;
			gdiff_mode++;
			break;
		case 'n':
			showbare = true;
			break;
		case 'O':
			diffops = 1;
			break;
		case 't':
			threshold = atoi (optarg);
			printf ("%s\n", optarg);
			break;
		case 'd':
			delta = 1;
			break;
		case 'D':
			disasm = true;
			break;
		case 'h':
			return show_help (1);
		case 's':
			mode = MODE_DIST;
			break;
		case 'x':
			mode = MODE_COLS;
			break;
		case 'v':
			printf ("radiff2 v"R2_VERSION"\n");
			return 0;
		case 'j':
			diffmode = 'j';
			break;
		default:
			return show_help (0);
		}
	}
	
	if (argc<3 || optind+2>argc)
		return show_help (0);

	if (optind<argc) {
		file = argv[optind];
	} else {
		file = NULL;
	}
	
	if (optind+1<argc) {
		file2 = argv[optind+1];
	} else {
		file2 = NULL;
	}

	switch (mode) {
	case MODE_GRAPH:
	case MODE_CODE:
		c = opencore (file);
		if (!c) eprintf ("Cannot open '%s'\n", r_str_get (file));
		c2 = opencore (file2);
		if (!c || !c2) {
			eprintf ("Cannot open '%s'\n", r_str_get (file2));
			return 1;
		}
		if (arch) {
			r_config_set (c->config, "asm.arch", arch);
			r_config_set (c2->config, "asm.arch", arch);
//.........这里部分代码省略.........

R_API int r_core_visual_panels(RCore *core) {
#define OS_INIT() ostack.size = 0; ostack.panels[0] = 0;
#define OS_PUSH(x) if (ostack.size<LIMIT) {ostack.panels[++ostack.size]=x;}
#define OS_POP() ((ostack.size>0)? ostack.panels[--ostack.size]:0)
	int okey, key, wheel;
	int w, h;
	int asm_comments = 0;
	int asm_bytes = 0;
	n_panels = 0;
	panels = NULL;
	callgraph = 0;
	_core = core;

	OS_INIT();
	w = r_cons_get_size (&h);
	can = r_cons_canvas_new (w, h);
	can->linemode = 1;
	can->color = r_config_get_i (core->config, "scr.color");
	// disable colors in disasm because canvas doesnt supports ansi text yet
	r_config_set_i (core->config, "scr.color", 0);
	//can->color = 0; 
	if (!can) {
		eprintf ("Cannot create RCons.canvas context\n");
		return R_FALSE;
	}
	n_panels = bbPanels (core, &panels);
	if (!panels) {
		r_config_set_i (core->config, "scr.color", can->color);
		free (can);
		return R_FALSE;
	}

	reloadPanels (core);

	asm_comments = r_config_get_i (core->config, "asm.comments");
	r_config_set_i (core->config, "asm.comments", 0);
	asm_bytes = r_config_get_i (core->config, "asm.bytes");
	r_config_set_i (core->config, "asm.bytes", 0);

repeat:
	core->cons->event_data = core;
	core->cons->event_resize = \
		(RConsEvent)r_core_panels_refresh;
	w = r_cons_get_size (&h);
	Layout_run (panels);
	r_core_panels_refresh (core);
	wheel = r_config_get_i (core->config, "scr.wheel");
	if (wheel)
		r_cons_enable_mouse (R_TRUE);

	// r_core_graph_inputhandle()
	okey = r_cons_readchar ();
	key = r_cons_arrow_to_hjkl (okey);

	switch (key) {
	case ' ':
	case '\n':
		if (menu_y) {
			const char *action = menus_sub[menu_x][menu_y-1];
			eprintf ("ACTION %s\n", action);
			if (strstr (action, "New")) {
				int i;
				// add new panel for testing
				for (i=0; panels[i].text; i++) {
					// find last panel
				}
				panels[i].text = strdup ("Test");
				panels[i].cmd = r_str_newf ("pxW $r-2");
				panels[i].addr = core->offset;
				panels[i].type = PANEL_TYPE_FRAME;
				i++;
				n_panels++;
				panels[i].text = NULL;
			}
			if (strstr (action, "Quit")) {
				goto beach;
			}
		}
		break;
	case '?':
		r_cons_clear00 ();
		r_cons_printf ("Visual Ascii Art Panels:\n"
		" !    run r2048 game\n"
		" .    - center graph to the current node\n"
		" :    - run r2 command in prompt\n"
		" hl   - toggle scr.color\n"
		" HL   - move vertical column split\n"
		" JK   - select prev/next panels\n"
		" jk   - scroll/select menu\n"
		" q    - quit, back to visual mode\n"
		);
		r_cons_flush ();
		r_cons_any_key (NULL);
		break;
	case ':':
		core->vmode = R_FALSE;
		r_core_visual_prompt_input (core);
		core->vmode = R_TRUE;
		break;
	case 'C':
//.........这里部分代码省略.........

int main(int argc, char **argv) {
    int         maxtokens = 50;
    int         ntokens, verbose = 0, i;
    Tokenizer  *tkz;
    const char *sep;
    char        str[100];

#ifdef NDEBUG
    eprintf("[email protected]%s:%d:"
            "Unit tests must be compiled without -DNDEBUG flag\n",
            __FILE__, __LINE__);
#endif

    switch (argc) {
    case 1:
        break;
    case 2:
        if(strncmp(argv[1], "-v", 2) != 0)
            eprintf("usage: xtokenizer [-v]\n");
        verbose = 1;
        break;
    default:
        eprintf("usage: xtokenizer [-v]\n");
    }

    tkz = Tokenizer_new(maxtokens);
    assert(Tokenizer_ntokens(tkz) == 0);
    strcpy(str, "; now;   \t: \t is       ::the  ,time  \n,");
    sep = ";:,";
    if(verbose) {
        printf("sep=\"%s\"\n", sep);
        printf("str=\"%s\"\n", str);
    }
    ntokens = Tokenizer_split(tkz, str, sep);
    if(verbose) {
        printf("ntokens=%d\n", ntokens);
        fflush(stdout);
    }
    assert(ntokens == Tokenizer_ntokens(tkz));
    assert(ntokens == 5);
    assert(strcmp(Tokenizer_token(tkz, 0), " now") == 0);
    assert(strcmp(Tokenizer_token(tkz, 1), "   \t") == 0);
    assert(strcmp(Tokenizer_token(tkz, 2), " \t is       ") == 0);
    assert(strcmp(Tokenizer_token(tkz, 3), "the  ") == 0);
    assert(strcmp(Tokenizer_token(tkz, 4), "time  \n") == 0);

    if(verbose) {
        for(i = 0; i < ntokens; ++i)
            printf("%4d \"%s\"\n", i, Tokenizer_token(tkz, i));
    }

    ntokens = Tokenizer_strip(tkz, " \t\n");
    assert(ntokens == 4);
    assert(strcmp(Tokenizer_token(tkz, 0), "now") == 0);
    assert(strcmp(Tokenizer_token(tkz, 1), "is") == 0);
    assert(strcmp(Tokenizer_token(tkz, 2), "the") == 0);
    assert(strcmp(Tokenizer_token(tkz, 3), "time") == 0);

    assert(Tokenizer_find(tkz, "now") == 0);
    assert(Tokenizer_find(tkz, "is") == 1);
    assert(Tokenizer_find(tkz, "the") == 2);
    assert(Tokenizer_find(tkz, "time") == 3);
    assert(Tokenizer_find(tkz, "not there") == ntokens);

    if(verbose) {
        printf("after stripping extraneous chars, ntokens is %d\n", ntokens);
        for(i = 0; i < ntokens; ++i)
            printf("%4d \"%s\"\n", i, Tokenizer_token(tkz, i));
        printf("Tokenizer_print:\n");
        Tokenizer_print(tkz, stdout);
    }

    strcpy(str, "afasf");
    ntokens = Tokenizer_split(tkz, str, ":");
    assert(ntokens == 1);

    strcpy(str, "");
    ntokens = Tokenizer_split(tkz, str, ":");
    assert(ntokens == 0);

    Tokenizer_free(tkz);

    unitTstResult("Tokenizer", "OK");
    fflush(stdout);

    return 0;
}

bool uiAskNextVolume(wchar *VolName,size_t MaxSize)
{
    eprintf(St(MAskNextVol),VolName);
    return Ask(St(MContinueQuit))!=2;
}

int r_bin_mdmp_init_directory(struct r_bin_mdmp_obj *obj, PMINIDUMP_DIRECTORY dir)
{
	size_t i, j, k;
	void *p, *m;
	switch (dir->StreamType) {
	case UnusedStream:
		break;
	case ThreadListStream:
		if (r_bin_mdmp_directory_check(obj, dir, sizeof(MINIDUMP_THREAD), "ThreadListStream")) {
			r_list_append(obj->threads, obj->b->buf + dir->Location.Rva);
		};
		break;
	case ModuleListStream:
		if (r_bin_mdmp_directory_check(obj, dir, sizeof(MINIDUMP_MODULE_LIST), "ModuleListStream"))
		{
			p = obj->b->buf + dir->Location.Rva;
			j = ((PMINIDUMP_MODULE_LIST)p)->NumberOfModules;
			for (i = 0; i < j; i++) {
				p = (void *)(&((PMINIDUMP_MODULE_LIST)p)->Modules[i]);
				if (p - (void *)obj->b->buf + sizeof(MINIDUMP_MODULE) > obj->b->length) {
					eprintf("Warning in r_bin_mdmp_init_directory: length too short, not enough space for all MINIDUMP_MODULE\n");
					break;
				}
				r_list_append(obj->modules, p);
			};
		};
		break;
	case MemoryListStream:
		break;
	case ExceptionStream:
		break;
	case SystemInfoStream:
		if (obj->system_info)
		{
			eprintf("Warning in r_bin_mdmp_init_directory: another SystemInfoStream encountered, ignored\n");
			return R_FALSE;
		}
		if (r_bin_mdmp_directory_check(obj, dir, sizeof(MINIDUMP_SYSTEM_INFO), "SystemInfoStream"))
		{
			obj->system_info = (PMINIDUMP_SYSTEM_INFO)(obj->b->buf + dir->Location.Rva);
		};
		break;
	case ThreadExListStream:
		break;
	case Memory64ListStream:
		if (r_bin_mdmp_directory_check(obj, dir, sizeof(MINIDUMP_MEMORY64_LIST), "Memory64ListStream"))
		{
			p = obj->b->buf + dir->Location.Rva;
			j = ((PMINIDUMP_MEMORY64_LIST)p)->NumberOfMemoryRanges;
			for (i = 0; i < j; i++) {
				p = (void *)(&((PMINIDUMP_MEMORY64_LIST)p)->MemoryRanges[i]);
				if (p - (void *)obj->b->buf + sizeof(MINIDUMP_MEMORY_DESCRIPTOR64) > obj->b->length) {
					eprintf("Warning in r_bin_mdmp_init_directory: length too short, not enough space for all MINIDUMP_MEMORY_DESCRIPTOR64\n");
					break;
				}
				r_list_append(obj->memory64, p);
			};
		};
		break;
	case CommentStreamA:
		break;
	case CommentStreamW:
		break;
	case HandleDataStream:
		break;
	case FunctionTableStream:
		break;
	case UnloadedModuleListStream:
		break;
	case MiscInfoStream:
		if (dir->Location.Rva + dir->Location.DataSize > obj->b->length)
		{
			eprintf("Warning in r_bin_mdmp_init_directory: length too short, not enough space for MiscInfoStream\n");
			return R_FALSE;
		}
		p = obj->b->buf + dir->Location.Rva;
		i = ((PMINIDUMP_MISC_INFO)p)->SizeOfInfo;
		if (i != dir->Location.DataSize) {
			eprintf("Warning in r_bin_mdmp_init_directory: MINIDUMP_MISC_INFO DataSize size mismatch\n");
			return R_FALSE;
		}
		if(!(m = malloc(sizeof(MINIDUMP_MISC_INFO_N)))) {
			eprintf("Warning in r_bin_mdmp_init_directory: malloc failed\n");
			return R_FALSE;
		}
		memset(m, 0, sizeof(MINIDUMP_MISC_INFO_N));
		if (i <= sizeof(MINIDUMP_MISC_INFO_N)) {
			memcpy(m, p, i);
		} else {
			memcpy (m, p, sizeof(MINIDUMP_MISC_INFO_N));
			eprintf ("Warning in r_bin_mdmp_init_directory: PMINIDUMP_MISC_INFO structure bigger than expected, truncated from %d\n", (int)i);
		}
		r_list_append(obj->misc_info, m);
		break;
	case MemoryInfoListStream:
		if (r_bin_mdmp_directory_check(obj, dir, sizeof(MINIDUMP_MEMORY_INFO_LIST), "MemoryInfoListStream"))
		{
			p = obj->b->buf + dir->Location.Rva;
			if ((sizeof(MINIDUMP_MEMORY_INFO_LIST) != ((PMINIDUMP_MEMORY_INFO_LIST)p)->SizeOfHeader) || (sizeof(MINIDUMP_MEMORY_INFO) != ((PMINIDUMP_MEMORY_INFO_LIST)p)->SizeOfEntry))
			{
//.........这里部分代码省略.........

//.........这里部分代码省略.........
		break;
	case R_ANAL_OP_TYPE_ADD:
		if (!a1 || !strcmp (a0, a1)) {
			snprintf (ret, sizeof (ret), "%s += %s", r0, a0);
		} else {
			snprintf (ret, sizeof (ret), "%s = %s + %s", r0, a0, a1);
		}
		break;
	case R_ANAL_OP_TYPE_SUB:
		if (!a1 || !strcmp (a0, a1)) {
			snprintf (ret, sizeof (ret), "%s -= %s", r0, a0);
		} else {
			snprintf (ret, sizeof (ret), "%s = %s - %s", r0, a0, a1);
		}
		break;
	case R_ANAL_OP_TYPE_MUL:
		if (!a1 || !strcmp (a0, a1)) {
			snprintf (ret, sizeof (ret), "%s *= %s", r0, a0);
		} else {
			snprintf (ret, sizeof (ret), "%s = %s * %s", r0, a0, a1);
		}
		break;
	case R_ANAL_OP_TYPE_DIV:
		if (!a1 || !strcmp (a0, a1)) {
			snprintf (ret, sizeof (ret), "%s /= %s", r0, a0);
		} else snprintf (ret, sizeof (ret), "%s = %s / %s", r0, a0, a1);
		break;
	case R_ANAL_OP_TYPE_AND:
		if (!a1 || !strcmp (a0, a1)) {
			snprintf (ret, sizeof (ret), "%s &= %s", r0, a0);
		} else snprintf (ret, sizeof (ret), "%s = %s & %s", r0, a0, a1);
		break;
	case R_ANAL_OP_TYPE_OR:
		if (!a1 || !strcmp (a0, a1)) {
			snprintf (ret, sizeof (ret), "%s |= %s", r0, a0);
		} else snprintf (ret, sizeof (ret), "%s = %s | %s", r0, a0, a1);
		break;
	case R_ANAL_OP_TYPE_XOR:
		if (!a1 || !strcmp (a0, a1)) {
			snprintf (ret, sizeof (ret), "%s ^= %s", r0, a0);
		} else snprintf (ret, sizeof (ret), "%s = %s ^ %s", r0, a0, a1);
		break;
	case R_ANAL_OP_TYPE_LEA:
		snprintf (ret, sizeof (ret), "%s -> %s", r0, a0);
		break;
	case R_ANAL_OP_TYPE_CMP:
		memcpy (ret, ";", 2);
		break;
	case R_ANAL_OP_TYPE_NOP:
		memcpy (ret, "nop", 4);
		break;
	case R_ANAL_OP_TYPE_RET:
		memcpy (ret, "ret", 4);
		break;
	case R_ANAL_OP_TYPE_CRET:
		if ((bb = r_anal_bb_from_offset (anal, op->addr))) {
			cstr = r_anal_cond_to_string (bb->cond);
			snprintf (ret, sizeof (ret), "if (%s) ret", cstr);
			free (cstr);
		} else {
			strcpy (ret, "if (unk) ret");
		}
		break;
	case R_ANAL_OP_TYPE_LEAVE:
		memcpy (ret, "leave", 6);
		break;
	case R_ANAL_OP_TYPE_MOD:
		if (!a1 || !strcmp (a0, a1)) {
			snprintf (ret, sizeof (ret), "%s %%= %s", r0, a0);
		} else {
			snprintf (ret, sizeof (ret), "%s = %s %% %s", r0, a0, a1);
		}
		break;
	case R_ANAL_OP_TYPE_XCHG:
		if (!a1 || !strcmp (a0, a1)) {
			snprintf (ret, sizeof (ret), "tmp = %s; %s = %s; %s = tmp", r0, r0, a0, a0);
		} else {
			snprintf (ret, sizeof (ret), "%s = %s ^ %s", r0, a0, a1);
		}
		break;
	case R_ANAL_OP_TYPE_ROL:
	case R_ANAL_OP_TYPE_ROR:
	case R_ANAL_OP_TYPE_SWITCH:
	case R_ANAL_OP_TYPE_CASE:
		eprintf ("Command not implemented.\n");
		free (r0);
		free (a0);
		free (a1);
		return NULL;
	default:
		free (r0);
		free (a0);
		free (a1);
		return NULL;
	}
	free (r0);
	free (a0);
	free (a1);
	return strdup (ret);
}

static void feh_load_options_for_theme(char *theme)
{
	FILE *fp = NULL;
	char *home = getenv("HOME");
	char *rcpath = NULL;
	char *oldrcpath = NULL;
	char *confbase = getenv("XDG_CONFIG_HOME");
	char s[1024], s1[1024], s2[1024];
	int cont = 0;
	int bspos;

	if (!home)
		eprintf("You have no HOME, cannot read themes");

	oldrcpath = estrjoin("/", home, ".fehrc", NULL);

	if (confbase)
		rcpath = estrjoin("/", confbase, "feh/themes", NULL);
	else
		rcpath = estrjoin("/", home, ".config/feh/themes", NULL);

	fp = fopen(rcpath, "r");

	free(rcpath);

	if (!fp && ((fp = fopen(oldrcpath, "r")) != NULL))
		weprintf("The theme config file was moved from ~/.fehrc to "
			"~/.config/feh/themes. Run\n"
			"    mkdir -p ~/.config/feh; mv ~/.fehrc ~/.config/feh/themes\n"
			"to fix this.");

	free(oldrcpath);

	if (!fp && ((fp = fopen("/etc/feh/themes", "r")) == NULL))
		return;

	/* Oooh. We have an options file :) */
	for (; fgets(s, sizeof(s), fp);) {
		s1[0] = '\0';
		s2[0] = '\0';

		if (cont) {
			sscanf(s, " %[^\n]\n", (char *) &s2);
			if (!*s2)
				break;
			D(("Got continued options %s\n", s2));
		} else {
			sscanf(s, "%s %[^\n]\n", (char *) &s1, (char *) &s2);
			if (!(*s1) || (!*s2) || (*s1 == '\n') || (*s1 == '#')) {
				cont = 0;
				continue;
			}
			D(("Got theme/options pair %s/%s\n", s1, s2));
		}

		if (!strcmp(s1, theme) || cont) {

			bspos = strlen(s2)-1;

			if (s2[bspos] == '\\') {
				D(("Continued line\n"));
				s2[bspos] = '\0';
				cont = 1;
				/* A trailing whitespace confuses the option parser */
				if (bspos && (s2[bspos-1] == ' '))
					s2[bspos-1] = '\0';
			} else
				cont = 0;

			D(("A match. Using options %s\n", s2));
			feh_parse_options_from_string(s2);

			if (!cont)
				break;
		}
	}
	fclose(fp);
	return;
}

static void print_escaped_string (const char *str, int len) {
  eprintf ("\"");
  const char *end = str + len;
  while (str < end) {
    int n = valid_utf8_char (str);
    if (n < 0) {
      eprintf ("\\x%02x", (int)(unsigned char)*str);
      str ++;
    } else if (n >= 2) {
      int i;
      for (i = 0; i < n; i++) {
        eprintf ("%c", *(str ++));
      }
    } else if (((unsigned char)*str) >= ' ' && *str != '"' && *str != '\\') {
      eprintf ("%c", *str);      
      str ++;
    } else {
      switch (*str) {
      case '\n':
        eprintf("\\n");
        break;
      case '\r':
        eprintf("\\r");
        break;
      case '\t':
        eprintf("\\t");
        break;
      case '\b':
        eprintf("\\b");
        break;
      case '\a':
        eprintf("\\a");
        break;
      case '\\':
        eprintf ("\\\\");
        break;
      case '"':
        eprintf ("\\\"");
        break;
      default:
        eprintf ("\\x%02x", (int)(unsigned char)*str);
        break;
      }
      str ++;
    }
  }
  eprintf ("\"");
}

void printvect(string name, vector vec)
{
  eprintf("[%s: %12s  %10.5f  %10.5f  %10.5f]\n",
	  getargv0(), name, vec[0], vec[1], vec[2]);
}

static void print_offset (void) {
  int i;
  for (i = 0; i < multiline_offset; i++) {
    eprintf (" ");
  }
}

//.........这里部分代码省略.........
          }
          break;
        default:
          if (Switch[1]=='+')
          {
            InclFileAttr|=GetExclAttr(Switch+2);
            InclAttrSet=true;
          }
          else
            ExclFileAttr|=GetExclAttr(Switch+1);
          break;
      }
      break;
    case 'F':
      if (Switch[1]==0)
        FreshFiles=true;
      else
        BadSwitch(Switch);
      break;
    case 'H':
      switch (toupperw(Switch[1]))
      {
        case 'P':
          EncryptHeaders=true;
          if (Switch[2]!=0)
          {
            Password.Set(Switch+2);
            cleandata((void *)Switch,wcslen(Switch)*sizeof(Switch[0]));
          }
          else
            if (!Password.IsSet())
            {
              uiGetPassword(UIPASSWORD_GLOBAL,NULL,&Password);
              eprintf(L"\n");
            }
          break;
        default :
          BadSwitch(Switch);
          break;
      }
      break;
    case 'I':
      if (wcsnicomp(Switch+1,L"LOG",3)==0)
      {
        wcsncpyz(LogName,Switch[4]!=0 ? Switch+4:DefLogName,ASIZE(LogName));
        break;
      }
      if (wcsicomp(Switch+1,L"SND")==0)
      {
        Sound=true;
        break;
      }
      if (wcsicomp(Switch+1,L"ERR")==0)
      {
        MsgStream=MSG_STDERR;
        break;
      }
      if (wcsnicomp(Switch+1,L"EML",3)==0)
      {
        wcsncpyz(EmailTo,Switch[4]!=0 ? Switch+4:L"@",ASIZE(EmailTo));
        break;
      }
      if (wcsicomp(Switch+1,L"NUL")==0)
      {
        MsgStream=MSG_NULL;
        break;

R_API int r_core_file_reopen(RCore *core, const char *args, int perm, int loadbin) {
	int isdebug = r_config_get_i (core->config, "cfg.debug");
	char *path;
	ut64 laddr = r_config_get_i (core->config, "bin.laddr");
	RCoreFile *file = NULL;
	RCoreFile *ofile = core->file;
	RBinFile *bf = ofile ? r_bin_file_find_by_fd (core->bin, ofile->fd)
		: NULL;
	RIODesc *odesc = (core->io && ofile) ? r_io_desc_get (core->io, ofile->fd) : NULL;
	char *ofilepath = NULL, *obinfilepath = (bf && bf->file)? strdup (bf->file): NULL;
	int ret = false;
	ut64 origoff = core->offset;
	if (odesc) {
		if (odesc->referer) {
			ofilepath = odesc->referer;
		} else if (odesc->uri) {
			ofilepath = odesc->uri;
		}
	}

	if (r_sandbox_enable (0)) {
		eprintf ("Cannot reopen in sandbox\n");
		free (obinfilepath);
		return false;
	}
	if (!core->file) {
		eprintf ("No file opened to reopen\n");
		free (ofilepath);
		free (obinfilepath);
		return false;
	}
	int newpid = odesc? odesc->fd: -1;

	if (isdebug) {
		r_debug_kill (core->dbg, core->dbg->pid, core->dbg->tid, 9); // KILL
		perm = 7;
	} else {
		if (!perm) {
			perm = 4; //R_PERM_R;
		}
	}
	if (!ofilepath) {
		eprintf ("Unknown file path");
		free (obinfilepath);
		return false;
	}

	// HACK: move last mapped address to higher place
	// XXX - why does this hack work?
	// when the new memory maps are created.
	path = strdup (ofilepath);
	free (obinfilepath);
	obinfilepath = strdup (ofilepath);

	// r_str_trim (path);
	file = r_core_file_open (core, path, perm, laddr);
	if (file) {
		bool had_rbin_info = false;

		if (ofile) {
			if (r_bin_file_delete (core->bin, ofile->fd)) {
				had_rbin_info = true;
			}
		}
		r_core_file_close (core, ofile);
		r_core_file_set_by_file (core, file);
		ofile = NULL;
		odesc = NULL;
		//	core->file = file;
		eprintf ("File %s reopened in %s mode\n", path,
			(perm & R_PERM_W)? "read-write": "read-only");

		if (loadbin && (loadbin == 2 || had_rbin_info)) {
			ut64 baddr = r_config_get_i (core->config, "bin.baddr");
			ret = r_core_bin_load (core, obinfilepath, baddr);
			r_core_bin_update_arch_bits (core);
			if (!ret) {
				eprintf ("Error: Failed to reload rbin for: %s", path);
			}
		}

		if (core->bin->cur && core->io && r_io_desc_get (core->io, file->fd) && !loadbin) {
			//force here NULL because is causing uaf look this better in future XXX @alvarofe
			core->bin->cur = NULL;
		}
		// close old file
	} else if (ofile) {
		eprintf ("r_core_file_reopen: Cannot reopen file: %s with perms 0x%x,"
			" attempting to open read-only.\n", path, perm);
		// lower it down back
		//ofile = r_core_file_open (core, path, R_PERM_R, addr);
		r_core_file_set_by_file (core, ofile);
	} else {
		eprintf ("Cannot reopen\n");
	}
	if (isdebug) {
		int newtid = newpid;
		// XXX - select the right backend
		if (core->file) {
			newpid = r_io_fd_get_pid (core->io, core->file->fd);
//.........这里部分代码省略.........

/* hack from print */
R_API int r_print_format_length (const char *fmt) {
	int nargs, i, j, idx, times, endian;
	char *args, *bracket, tmp, last = 0;
	const char *arg = fmt;
	const char *argend = arg+strlen (fmt);
	char namefmt[8];
	int viewflags = 0;
	nargs = endian = i = j = 0;

	while (*arg && iswhitechar (*arg)) arg++;
	/* get times */
	times = atoi (arg);
	if (times > 0)
		while ((*arg>='0'&&*arg<='9')) arg++;
	bracket = strchr (arg,'{');
	if (bracket) {
		char *end = strchr (arg,'}');
		if (end == NULL) {
			eprintf ("No end bracket. Try pm {ecx}b @ esi\n");
			return 0;
		}
		*end='\0';
		times = r_num_math (NULL, bracket+1);
		arg = end + 1;
	}

	if (*arg=='\0')
		return 0;

	/* get args */
	args = strchr (arg, ' ');
	if (args) {
		int l=0, maxl = 0;
		argend = args;
		args = strdup (args+1);
		nargs = r_str_word_set0 (args+1);
		if (nargs == 0)
			R_FREE (args);
		for (i=0; i<nargs; i++) {
			int len = strlen (r_str_word_get0 (args+1, i));
			if (len>maxl) maxl = len;
		}
		l++;
		snprintf (namefmt, sizeof (namefmt), "%%%ds : ", maxl);
	}

	/* go format */
	i = 0;
	if (!times) times = 1;
	for (; times; times--) { // repeat N times
		const char * orig = arg;
		idx = 0;
		arg = orig;
		for (idx=0; arg<argend && *arg; idx++, arg++) {
			tmp = *arg;
		feed_me_again:
			if (tmp == 0 && last != '*')
				break;
			/* skip chars */
			switch (tmp) {
			case '*':
				if (i<=0) break;
				tmp = last;
				arg--;
				idx--;
				goto feed_me_again;
			case '+':
				idx--;
				viewflags = !viewflags;
				continue;
			case 'e': // tmp swap endian
				idx--;
				endian ^= 1;
				continue;
			case '.': // skip char
				i++;
				idx--;
				continue;
			case 'p':
				tmp = (sizeof (void*)==8)? 'q': 'x';
				break;
			case '?': // help
				idx--;
				return 0;
			}
			switch (tmp) {
			case 'e': i += 8; break;
			case 'q': i += 8; break;
			case 'b': i++; break;
			case 'c': i++; break;
			case 'B': i += 4; break;
			case 'i': i += 4; break;
			case 'd': i += 4; break;
			case 'x': i += 4; break;
			case 'w':
			case '1': i+=2; break;
			case 'z': // XXX unsupported
			case 'Z': // zero terminated wide string
				break;
//.........这里部分代码省略.........

static int modify_trace_bit(RDebug *dbg, xnu_thread *th, int enable) {
	R_DEBUG_REG_T *state;
  	kern_return_t kr;
	int ret;
	ret = xnu_thread_get_drx (dbg, th);
	if (ret == R_FALSE) {
		eprintf ("error to get drx registers modificy_trace_bit arm\n");
		return R_FALSE;
	}
	state = (R_DEBUG_REG_T)th->drx;
	if (state->flavor == ARM_DEBUG_STATE64) {
		state->uds.ds64.__mdscr_el1 = (state->uds64.__mdscr_el1 \
					& SS_ENABLE) & (enable ? SS_ENABLE : 0);

	} else if (state->flavor == ARM_DEBUG_STATE32) {
		R_REG_T *regs;
		ret = xnu_thread_get_gpr (dbg, th);
		if (ret == R_FALSE) {
			eprintf ("error to get gpr register modificy_trace_bit arm\n");
			return R_FALSE;
		}
		regs = (R_REG_T)th->gpr;
		if (enable) {
			int r, i = 0;
			RIOBind *bio = &dbg->io;
			(R_DEBUG_REG_T)th->oldstate = state;
			//set a breakpoint that will stop when the PC doesn't
			//match the current one
			//set the current PC as the breakpoint address
			state->uds.ds32.__bvr[i] = regs->ts_32.__pc;
			state->uds.ds32.__bcr[i] = BCR_M_IMVA_MISMATCH | //stop on address mismatch
				S_USER | //stop only in user mode
				BCR_ENABLE; // enable this breakpoint
			if (regs->ts_32.__cpsr & 0x20) {
				ut16 op;
				// Thumb breakpoint
				if (regs->ts_32.__pc & 2) {
					state->uds.ds32.__bcr[i] |= BAS_IMVA_2_3;
				} else {
					state->uds.ds32.__bcr[i] |= BAS_IMVA_0_1;
				}
				if (bio->read_at (bio->io, regs->ts_32.__pc,
						(void *)&op, 2) < 1) {
					eprintf ("Failed to read opcode modify_trace_bit\n");
					return false;
				}
				if (is_thumb_32 (op)) {
					eprintf ("Thumb32 chain stepping not supported yet\n");
					return false;
				} else {
					// Extend the number of bits to ignore for the mismatch
					state->uds.ds32.__bcr[i] |= BAS_IMVA_ALL;
				}
			} else {
				// ARM breakpoint
				state->uds.ds32.__bcr[i] |= BAS_IMVA_ALL; // Stop when any address bits change
			}
			//disable bits
			for (i = i + 1; i < 16; i++) {
				//Disable all others
				state->uds.ds32.__bcr[i] = 0;
				state->uds.ds32.__bvr[i] = 0;
			}
		} else {
			state->uds.ds32 = ((R_DEBUG_REG_T)th->oldstate)->uds.ds32; //we set the old state
		}
	} else {
		eprintf ("Bad flavor modificy_trace_bit arm\n");
		return false;
	}
	//set state
	th->count = state->dsh.count;
	memcpy (th->state, state->uds, th->count);
	if (!xnu_thread_set_drx (dbg, th)) {
		eprintf ("error to set drx modificy_trace_bit arm\n");
		return false;
	}
	return true;

#elif __POWERPC__
	// no need to do this here
	return false;
#else
#error "unknown architecture"
#endif
}

static ut64 num_callback(RNum *userptr, const char *str, int *ok) {
	RCore *core = (RCore *)userptr; // XXX ?
	RFlagItem *flag;
	RAnalOp op;
	ut64 ret = 0;
	*ok = 0;
	if (str[0]=='[') {
		int refsz = (core->assembler->bits & R_SYS_BITS_64)? 8: 4;
		const char *p = strchr (str+5, ':');
		ut64 n;
		// TODO: honor endian
		if (p) {
			refsz = atoi (str+1);
			str = p;
		}
		// push state
		{
			const char *q = r_num_calc_index (core->num, NULL);
			n = r_num_math (core->num, str+1);
			r_num_calc_index (core->num, q);
		}
		// pop state
		switch (refsz) {
		case 8: {
			ut64 num = 0;
			r_io_read_at (core->io, n, (ut8*)&num, sizeof (num));
			return num;
			}
		case 4: {
			ut32 num = 0;
			r_io_read_at (core->io, n, (ut8*)&num, sizeof (num));
			return num;
			}
		case 2: {
			ut16 num = 0;
			r_io_read_at (core->io, n, (ut8*)&num, sizeof (num));
			return num;
			}
		case 1: {
			ut8 num = 0;
			r_io_read_at (core->io, n, (ut8*)&num, sizeof (num));
			return num;
			}
		default:
			eprintf ("Invalid reference size: %d\n", refsz);
			break;
		}
	} else
	if (str[0]=='$') {
		*ok = 1;
		// TODO: group analop-dependant vars after a char, so i can filter
		r_anal_op (core->anal, &op, core->offset,
			core->block, core->blocksize);
		switch (str[1]) {
		case '.': // can use pc, sp, a0, a1, ...
			return r_debug_reg_get (core->dbg, str+2);
		case '{':
			{
				char *ptr, *bptr = strdup (str+2);
				ptr = strchr (bptr, '}');
				if (ptr != NULL) {
					ut64 ret;
					ptr[0]='\0';
					ret = r_config_get_i (core->config, bptr);
					free (bptr);
					return ret;
				}
			}
			return 0;
		case 'e': return op.eob;
		case 'j': return op.jump;
		case 'f': return op.fail;
		case 'r': return op.ref;
		case 'l': return op.length;
		case 'b': return core->blocksize;
		case 's': return core->file->size;
		case 'w': {
			int bits = r_config_get_i (core->config, "asm.bits");
			return bits/8;
			} break;
		case 'S': {
			RIOSection *s = r_io_section_get (core->io, 
				r_io_section_vaddr_to_offset (core->io, core->offset));
			return s? (str[2]=='S'?s->size: s->offset): 0;
			}
		case '?': return core->num->value;
		case '$': return core->offset;
		case 'o': return core->io->off;
		case 'C': return getref (core, atoi (str+2), 'r', R_ANAL_REF_TYPE_CALL);
		case 'J': return getref (core, atoi (str+2), 'r', R_ANAL_REF_TYPE_CODE);
		case 'D': return getref (core, atoi (str+2), 'r', R_ANAL_REF_TYPE_DATA);
		case 'X': return getref (core, atoi (str+2), 'x', R_ANAL_REF_TYPE_CALL);
		case 'I':
			  {
				  RAnalFunction *fcn = r_anal_fcn_find (core->anal, core->offset, 0);
				  if (fcn) return fcn->ninstr;
				  return 0;
			  }
		case 'F':
			  {
//.........这里部分代码省略.........

bool FileCreate(RAROptions *Cmd,File *NewFile,char *Name,wchar *NameW,
                OVERWRITE_MODE Mode,bool *UserReject,Int64 FileSize,
                uint FileTime)
{
  if (UserReject!=NULL)
    *UserReject=false;
  while (FileExist(Name,NameW))
  {
    if (Mode==OVERWRITE_NONE)
    {
      if (UserReject!=NULL)
        *UserReject=true;
      return(false);
    }
#ifdef SILENT
    Mode=OVERWRITE_ALL;
#endif
    if (Cmd->AllYes || Mode==OVERWRITE_ALL)
      break;
    if (Mode==OVERWRITE_ASK)
    {
      eprintf(St(MFileExists),Name);
      int Choice=Ask(St(MYesNoAllRenQ));
      if (Choice==1)
        break;
      if (Choice==2)
      {
        if (UserReject!=NULL)
          *UserReject=true;
        return(false);
      }
      if (Choice==3)
      {
        Cmd->Overwrite=OVERWRITE_ALL;
        break;
      }
      if (Choice==4)
      {
        if (UserReject!=NULL)
          *UserReject=true;
        Cmd->Overwrite=OVERWRITE_NONE;
        return(false);
      }
      if (Choice==5)
      {
        mprintf(St(MAskNewName));

        char NewName[NM];
#ifdef  _WIN_32
        File SrcFile;
        SrcFile.SetHandleType(FILE_HANDLESTD);
        int Size=SrcFile.Read(NewName,NM);
        NewName[Size]=0;
        OemToChar(NewName,NewName);
#else
        fgets(NewName,sizeof(NewName),stdin);
#endif
        RemoveLF(NewName);
        if (PointToName(NewName)==NewName)
          strcpy(PointToName(Name),NewName);
        else
          strcpy(Name,NewName);
        if (NameW!=NULL)
          *NameW=0;
        continue;
      }
      if (Choice==6)
        ErrHandler.Exit(USER_BREAK);
    }
  }
  if (NewFile!=NULL && NewFile->Create(Name,NameW))
    return(true);
  PrepareToDelete(Name,NameW);
  CreatePath(Name,NameW,true);
  return(NewFile!=NULL ? NewFile->Create(Name,NameW):DelFile(Name,NameW));
}

static int bin_strings (RCore *r, int mode, ut64 baddr, int va) {
	char *q, str[R_FLAG_NAME_SIZE];
	RBinSection *section;
	int hasstr, minstr, maxstr, rawstr;
	RBinString *string;
	RListIter *iter;
	RList *list;
	RBin *bin = r->bin;
	RBinFile * binfile = r_core_bin_cur (r);
	RBinPlugin *plugin = r_bin_file_cur_plugin (binfile);

	if (!binfile) return R_FALSE;
	minstr = r_config_get_i (r->config, "bin.minstr");
	maxstr = r_config_get_i (r->config, "bin.maxstr");
	rawstr = r_config_get_i (r->config, "bin.rawstr");
	binfile->rawstr = rawstr;

	if (!(hasstr = r_config_get_i (r->config, "bin.strings")))
		return 0;

	if (!plugin) return 0;
	if (plugin->info && plugin->name) {
		if (!strcmp (plugin->name, "any")) {
			if (!rawstr) {
#if 0
				eprintf ("NOTE: Use '-e bin.rawstr=true' or 'r2 -zz' or '.!rabin2 -zz $FILE'"
					" to find strings on unknown file types\n");
#endif
				return R_FALSE;

			}
		}
	}

#if 0
	if (bin->minstrlen == 0)
		bin->minstrlen = minstr;
	else plugin->minstrlen? plugin->minstrlen: 4;
#endif
		bin->minstrlen = minstr;
#if 0
	if (bin->minstrlen <= 0)
		bin->minstrlen = R_MIN (minstr, 4);
#endif
	minstr = bin->minstrlen;

	if ((list = r_bin_get_strings (bin)) == NULL)
		return