void
FTPInitializeAnonPassword(const FTPLIPtr lip)
{
if (lip == NULL)
return;
if (strcmp(lip->magic, kLibraryMagic))
return;
FTPInitializeOurHostName(lip);
if (lip->defaultAnonPassword[0] == '\0') {
#ifdef SPAM_PROBLEM_HAS_BEEN_SOLVED_FOREVER
GetUsrName(lip->defaultAnonPassword, sizeof(lip->defaultAnonPassword));
(void) STRNCAT(lip->defaultAnonPassword, "@");
/* Default to the "user@" notation
* supported by NcFTPd and wu-ftpd.
*/
if (lip->htried > 0)
(void) STRNCAT(lip->defaultAnonPassword, lip->ourHostName);
#else
(void) STRNCPY(lip->defaultAnonPassword, "NcFTP@");
#endif
}
} /* FTPInitializeAnonPassword */
int
HaveSpool(void)
{
#if defined(WIN32) || defined(_WINDOWS)
char ncftpbatch[260];
if (gHaveSpool < 0) {
gHaveSpool = 0;
if (gOurInstallationPath[0] != '\0') {
OurInstallationPath(ncftpbatch, sizeof(ncftpbatch), "ncftpbatch.exe");
gHaveSpool = (_access(ncftpbatch, F_OK) == 0) ? 1 : 0;
}
}
#elif defined(BINDIR)
char ncftpbatch[256];
if (gHaveSpool < 0) {
STRNCPY(ncftpbatch, BINDIR);
STRNCAT(ncftpbatch, "/");
STRNCAT(ncftpbatch, "ncftpbatch");
gHaveSpool = (access(ncftpbatch, X_OK) == 0) ? 1 : 0;
}
#else /* BINDIR */
if (gHaveSpool < 0) {
if (geteuid() == 0) {
gHaveSpool = (access("/usr/bin/ncftpbatch", X_OK) == 0) ? 1 : 0;
} else {
gHaveSpool = (system("ncftpbatch -X") == 0) ? 1 : 0;
}
}
#endif /* BINDIR */
return (gHaveSpool);
} /* HaveSpool */
static int format_att_mnemonic( x86_insn_t *insn, char *buf, int len) {
int size = 0;
char *suffix;
if (! insn || ! buf || ! len )
return(0);
memset( buf, 0, len );
/* do long jump/call prefix */
if ( insn->type == insn_jmp || insn->type == insn_call ) {
if (! is_imm_jmp( x86_operand_1st(insn) ) ||
(x86_operand_1st(insn))->datatype != op_byte ) {
/* far jump/call, use "l" prefix */
STRNCAT( buf, "l", len );
}
STRNCAT( buf, insn->mnemonic, len );
return ( strlen( buf ) );
}
/* do mnemonic */
STRNCAT( buf, insn->mnemonic, len );
/* do suffixes for memory operands */
if (!(insn->note & insn_note_nosuffix) &&
(insn->group == insn_arithmetic ||
insn->group == insn_logic ||
insn->group == insn_move ||
insn->group == insn_stack ||
insn->group == insn_string ||
insn->group == insn_comparison ||
insn->type == insn_in ||
insn->type == insn_out
)) {
if ( x86_operand_count( insn, op_explicit ) > 0 &&
is_memory_op( x86_operand_1st(insn) ) ){
size = x86_operand_size( x86_operand_1st( insn ) );
} else if ( x86_operand_count( insn, op_explicit ) > 1 &&
is_memory_op( x86_operand_2nd(insn) ) ){
size = x86_operand_size( x86_operand_2nd( insn ) );
}
}
if ( size == 1 ) suffix = "b";
else if ( size == 2 ) suffix = "w";
else if ( size == 4 ) suffix = "l";
else if ( size == 8 ) suffix = "q";
else suffix = "";
STRNCAT( buf, suffix, len );
return ( strlen( buf ) );
}
static int format_operand_native( x86_op_t *op, x86_insn_t *insn, char *buf,
int len) {
char str[MAX_OP_STRING];
switch (op->type) {
case op_register:
STRNCAT( buf, op->data.reg.name, len );
break;
case op_immediate:
get_operand_data_str( op, str, sizeof str );
STRNCAT( buf, str, len );
break;
case op_relative_near:
STRNCATF( buf, "0x%08X",
(unsigned int)(op->data.sbyte +
insn->addr + insn->size), len );
break;
case op_relative_far:
if ( op->datatype == op_word ) {
STRNCATF( buf, "0x%08X",
(unsigned int)(op->data.sword +
insn->addr + insn->size), len );
break;
} else {
STRNCATF( buf, "0x%08lX", op->data.sdword +
insn->addr + insn->size, len );
}
break;
case op_absolute:
case op_offset:
len -= format_seg( op, buf, len, native_syntax );
STRNCATF( buf, "0x%08lX", op->data.sdword, len );
break;
case op_expression:
len -= format_seg( op, buf, len, native_syntax );
len -= format_expr( &op->data.expression, buf, len,
native_syntax );
break;
case op_unused:
case op_unknown:
/* return 0-truncated buffer */
break;
}
return( strlen( buf ) );
}
static int format_raw_insn( x86_insn_t *insn, char *buf, int len ){
struct op_string opstr = { buf, len };
int i;
/* RAW style:
* ADDRESS|OFFSET|SIZE|BYTES|
* PREFIX|PREFIX_STRING|GROUP|TYPE|NOTES|
* MNEMONIC|CPU|ISA|FLAGS_SET|FLAGS_TESTED|
* STACK_MOD|STACK_MOD_VAL
* [|OP_TYPE|OP_DATATYPE|OP_ACCESS|OP_FLAGS|OP]*
*
* Register values are encoded as:
* NAME:TYPE:SIZE
*
* Effective addresses are encoded as:
* disp(base_reg,index_reg,scale)
*/
STRNCATF( buf, "0x%08X|", insn->addr , len );
STRNCATF( buf, "0x%08X|", insn->offset, len );
STRNCATF( buf, "%d|" , insn->size , len );
/* print bytes */
for ( i = 0; i < insn->size; i++ ) {
STRNCATF( buf, "%02X ", insn->bytes[i], len );
}
STRNCAT( buf, "|", len );
len -= format_insn_prefix_str( insn->prefix, buf, len );
STRNCATF( buf, "|%s|", insn->prefix_string , len );
STRNCATF( buf, "%s|", get_insn_group_str( insn->group ), len );
STRNCATF( buf, "%s|", get_insn_type_str( insn->type ) , len );
STRNCATF( buf, "%s|", insn->mnemonic , len );
STRNCATF( buf, "%s|", get_insn_cpu_str( insn->cpu ) , len );
STRNCATF( buf, "%s|", get_insn_isa_str( insn->isa ) , len );
/* insn note */
len -= format_insn_note( insn, buf, len );
len -= format_insn_eflags_str( insn->flags_set, buf, len );
STRNCAT( buf, "|", len );
len -= format_insn_eflags_str( insn->flags_tested, buf, len );
STRNCAT( buf, "|", len );
STRNCATF( buf, "%d|", insn->stack_mod, len );
STRNCATF( buf, "%d|", insn->stack_mod_val, len );
opstr.len = len;
x86_operand_foreach( insn, format_op_raw, &opstr, op_any );
return( strlen (buf) );
}
static int format_insn_prefix_str( enum x86_insn_prefix prefix, char *buf,
int len ) {
int len_orig = len;
/* concat all prefix strings */
if ( prefix & 1 ) { STRNCAT( buf, prefix_strings[1], len ); }
if ( prefix & 2 ) { STRNCAT( buf, prefix_strings[2], len ); }
if ( prefix & 4 ) { STRNCAT( buf, prefix_strings[3], len ); }
if ( prefix & 8 ) { STRNCAT( buf, prefix_strings[4], len ); }
/* return the number of characters added */
return (len_orig - len);
}
int x86_format_mnemonic(x86_insn_t *insn, char *buf, int len,
enum x86_asm_format format){
char str[MAX_OP_STRING];
memset( buf, 0, len );
STRNCAT( buf, insn->prefix_string, len );
if ( format == att_syntax ) {
format_att_mnemonic( insn, str, sizeof str );
STRNCAT( buf, str, len );
} else {
STRNCAT( buf, insn->mnemonic, len );
}
return( strlen( buf ) );
}
static int format_att_mnemonic( x86_insn_t *insn, char *buf, int len) {
int size = 0;
char *suffix;
if (! insn || ! buf || ! len )
return(0);
memset( buf, 0, len );
/* intel callf/call far is always an lcall */
if (! strcmp( "callf", insn->mnemonic ) ) {
STRNCAT( buf, "lcall", len );
return ( strlen( buf ) );
}
/* do long jump/call prefix */
if ( insn->type == insn_jmp || insn->type == insn_call ) {
if (! is_imm_jmp( x86_operand_1st(insn) ) ||
(x86_operand_1st(insn))->datatype != op_byte ) {
/* far jump/call, use "l" prefix */
STRNCAT( buf, "l", len );
}
STRNCAT( buf, insn->mnemonic, len );
return ( strlen( buf ) );
}
/* do mnemonic */
STRNCAT( buf, insn->mnemonic, len );
/* do suffixes for memory operands */
if ( x86_operand_count( insn, op_explicit ) > 0 &&
is_memory_op( x86_operand_1st(insn) ) ) {
size = x86_operand_size( x86_operand_1st( insn ) );
} else if ( x86_operand_count( insn, op_explicit ) > 1 &&
is_memory_op( x86_operand_2nd(insn) ) ) {
size = x86_operand_size( x86_operand_2nd( insn ) );
}
if ( size == 1 ) suffix = "b";
else if ( size == 2 ) suffix = "w";
else if ( size == 4 ) suffix = "l";
else if ( size == 8 ) suffix = "q";
else suffix = "";
STRNCAT( buf, suffix, len );
return ( strlen( buf ) );
}
/* Clones an existing site in the host list. */
void HostWinDup(void)
{
BookmarkPtr rsip;
char bmname[128];
if (gCurHostListItem != NULL) {
/* Use the extra slot in the array for the new one. */
rsip = &gBookmarkTable[gNumBookmarks];
*rsip = *gCurHostListItem;
STRNCAT(rsip->bookmarkName, "-copy");
STRNCPY(bmname, rsip->bookmarkName);
gNumBookmarks++;
SaveAndReload();
/* Note: newly reallocated array, modified gNumBookmarks */
rsip = SearchBookmarkTable(bmname);
if (rsip == NULL)
rsip = &gBookmarkTable[0];
gCurHostListItem = rsip;
gHilitedHost = BMTINDEX(rsip);
gHostListWinStart = BMTINDEX(rsip) - gHostListPageSize + 1;
if (gHostListWinStart < 0)
gHostListWinStart = 0;
DrawHostList();
} else {
HostWinMsg("Nothing to duplicate.");
}
DrawHostList();
} /* HostWinDup */
static int format_seg( x86_op_t *op, char *buf, int len,
enum x86_asm_format format ) {
int len_orig = len;
char *reg = "";
if (! op || ! buf || ! len || ! op->flags) {
return(0);
}
if ( op->type != op_absolute && op->type != op_offset &&
op->type != op_expression ) {
return(0);
}
if (! (int) op->flags & 0xF00 ) {
return(0);
}
switch (op->flags & 0xF00) {
case op_es_seg:
reg = "es";
break;
case op_cs_seg:
reg = "cs";
break;
case op_ss_seg:
reg = "ss";
break;
case op_ds_seg:
reg = "ds";
break;
case op_fs_seg:
reg = "fs";
break;
case op_gs_seg:
reg = "gs";
break;
default:
break;
}
if (! reg[0] ) {
return( 0 );
}
switch( format ) {
case xml_syntax:
STRNCAT( buf, "\t\t\t<segment ", len );
STRNCATF( buf, "value=\"%s\"/>\n", reg, len );
break;
case att_syntax:
STRNCATF( buf, "%%%s:", reg, len );
break;
default:
STRNCATF( buf, "%s:", reg, len );
break;
}
return( len_orig - len ); /* return length of appended string */
}
static int format_operand_att( x86_op_t *op, x86_insn_t *insn, char *buf,
int len) {
char str[MAX_OP_STRING];
memset (str, 0, sizeof str);
switch ( op->type ) {
case op_register:
STRNCATF( buf, "%%%s", op->data.reg.name, len );
break;
case op_immediate:
get_operand_data_str( op, str, sizeof str );
STRNCATF( buf, "$%s", str, len );
break;
case op_relative_near:
STRNCATF( buf, "0x%08X",
(unsigned int)(op->data.sbyte +
insn->addr + insn->size), len );
break;
case op_relative_far:
if (op->datatype == op_word) {
STRNCATF( buf, "0x%08X",
(unsigned int)(op->data.sword +
insn->addr + insn->size), len );
} else {
STRNCATF( buf, "0x%08X",
(unsigned int)(op->data.sdword +
insn->addr + insn->size), len );
}
break;
case op_absolute:
case op_offset:
/* ATT requires a '*' before absolute JMP/CALL ops */
if (insn->type == insn_jmp || insn->type == insn_call)
STRNCAT( buf, "*", len );
len -= format_seg( op, buf, len, att_syntax );
STRNCATF( buf, "0x%08lX", op->data.sdword, len );
break;
case op_expression:
len -= format_seg( op, buf, len, att_syntax );
len -= format_expr( &op->data.expression, buf, len,
att_syntax );
break;
case op_unused:
case op_unknown:
/* return 0-truncated buffer */
break;
}
return ( strlen( buf ) );
}
/*
* sprints register types to a string. the register types can be ORed
* together.
*/
static void get_operand_regtype_str( int regtype, char *str, int len )
{
static struct {
char *name;
int value;
} operand_regtypes[] = {
{"reg_gen" , 0x00001},
{"reg_in" , 0x00002},
{"reg_out" , 0x00004},
{"reg_local" , 0x00008},
{"reg_fpu" , 0x00010},
{"reg_seg" , 0x00020},
{"reg_simd" , 0x00040},
{"reg_sys" , 0x00080},
{"reg_sp" , 0x00100},
{"reg_fp" , 0x00200},
{"reg_pc" , 0x00400},
{"reg_retaddr", 0x00800},
{"reg_cond" , 0x01000},
{"reg_zero" , 0x02000},
{"reg_ret" , 0x04000},
{"reg_src" , 0x10000},
{"reg_dest" , 0x20000},
{"reg_count" , 0x40000},
{NULL, 0}, //end
};
unsigned int i;
memset( str, 0, len );
//go thru every type in the enum
for ( i = 0; operand_regtypes[i].name; i++ ) {
//skip if type is not set
if(! (regtype & operand_regtypes[i].value) )
continue;
//not the first time around
if( str[0] ) {
STRNCAT( str, " ", len );
}
STRNCAT(str, operand_regtypes[i].name, len );
}
}
void FileTransfer::ProcessListViewDBLCLK(HWND hwnd, char *Path, char *PathTmp,
int iItem)
{
SendMessage(m_hwndFTProgress, PBM_SETPOS, 0, 0);
SetWindowText(m_hwndFTStatus, "");
STRNCPY(PathTmp, Path, rfbMAX_PATH);
char buffer[rfbMAX_PATH];
char buffer_tmp[16];
ListView_GetItemText(hwnd, iItem, 0, buffer, rfbMAX_PATH);
ListView_GetItemText(hwnd, iItem, 1, buffer_tmp, 16);
if (strcmp(buffer_tmp, m_FTClientItemInfo.folderText) == 0) {
BlockingFileTransferDialog(FALSE);
if (strlen(PathTmp) >= 2) STRNCAT(PathTmp, "\\", rfbMAX_PATH);
STRNCAT(PathTmp, buffer, rfbMAX_PATH);
if (hwnd == m_hwndFTClientList) ShowClientItems(PathTmp);
if (hwnd == m_hwndFTServerList) SendFileListRequestMessage(PathTmp, 0);
}
}
void
PrintStartupBanner(void)
{
char v[80], *cp;
char vdate[32];
/* Print selected information from the version ID. */
vdate[0] = '\0';
(void) STRNCPY(v, gVersion + 5);
cp = strchr(v, ',');
if (cp != NULL) {
*cp = '\0';
cp[-5] = '\0';
(void) STRNCPY(vdate, " (");
(void) STRNCAT(vdate, v + 16);
(void) STRNCAT(vdate, ", ");
(void) STRNCAT(vdate, cp - 4);
(void) STRNCAT(vdate, ")");
}
#if defined(BETA) && (BETA > 0)
(void) fprintf(stdout, "%s%.11s beta %d%s%s by Mike Gleason ([email protected]).\n",
tcap_boldface,
gVersion + 5,
BETA,
tcap_normal,
vdate
);
#else
(void) fprintf(stdout, "%s%.11s%s%s by Mike Gleason ([email protected]).\n",
tcap_boldface,
gVersion + 5,
tcap_normal,
vdate
);
#endif
(void) fflush(stdout);
} /* PrintStartupBanner */
void FileTransfer::GetTVPath(HWND hwnd, HTREEITEM hTItem, char *path)
{
char szText[rfbMAX_PATH];
TVITEM _tvi;
path[0] = '\0';
do {
_tvi.mask = TVIF_TEXT | TVIF_HANDLE;
_tvi.hItem = hTItem;
_tvi.pszText = szText;
_tvi.cchTextMax = rfbMAX_PATH;
TreeView_GetItem(hwnd, &_tvi);
STRNCAT(path, "\\", rfbMAX_PATH);
STRNCAT(path, _tvi.pszText, rfbMAX_PATH);
hTItem = TreeView_GetParent(hwnd, hTItem);
}
while (hTItem != NULL);
char path_tmp[rfbMAX_PATH], path_out[rfbMAX_PATH];
path_tmp[0] = '\0';
path_out[0] = '\0';
int len = (int)strlen(path);
int ii = 0;
for (int i = (len - 1); i >= 0; i--) {
if (path[i] == '\\') {
StrInvert(path_tmp);
STRCAT(path_out, path_tmp);
STRCAT(path_out, "\\");
path_tmp[0] = '\0';
ii = 0;
} else {
path_tmp[ii] = path[i];
path_tmp[ii + 1] = '\0';
ii++;
}
}
if (path_out[strlen(path_out) - 1] == '\\')
path_out[strlen(path_out) - 1] = '\0';
STRNCPY(path, path_out, rfbMAX_PATH);
}
/*
* Translate a string into allocated memory, replacing special chars with
* printable chars. Returns NULL when out of memory.
*/
char_u *transstr(char_u *s)
{
char_u *res;
char_u *p;
int l, len, c;
char_u hexbuf[11];
if (has_mbyte) {
/* Compute the length of the result, taking account of unprintable
* multi-byte characters. */
len = 0;
p = s;
while (*p != NUL) {
if ((l = (*mb_ptr2len)(p)) > 1) {
c = (*mb_ptr2char)(p);
p += l;
if (vim_isprintc(c))
len += l;
else {
transchar_hex(hexbuf, c);
len += (int)STRLEN(hexbuf);
}
} else {
l = byte2cells(*p++);
if (l > 0)
len += l;
else
len += 4; /* illegal byte sequence */
}
}
res = alloc((unsigned)(len + 1));
} else
res = alloc((unsigned)(vim_strsize(s) + 1));
if (res != NULL) {
*res = NUL;
p = s;
while (*p != NUL) {
if (has_mbyte && (l = (*mb_ptr2len)(p)) > 1) {
c = (*mb_ptr2char)(p);
if (vim_isprintc(c))
STRNCAT(res, p, l); /* append printable multi-byte char */
else
transchar_hex(res + STRLEN(res), c);
p += l;
} else
STRCAT(res, transchar_byte(*p++));
}
}
return res;
}
static int
SwapBookmarkFiles(void)
{
char pidStr[32];
char pathName[256], path2[256];
(void) OurDirectoryPath(path2, sizeof(path2), kBookmarkFileName);
(void) OurDirectoryPath(pathName, sizeof(pathName), kTmpBookmarkFileName);
(void) sprintf(pidStr, "-%u.txt", (unsigned int) getpid());
(void) STRNCAT(pathName, pidStr);
(void) remove(path2);
if (rename(pathName, path2) < 0) {
return (-1);
}
return (0);
} /* SwapBookmarkFiles */
/* Saves a Bookmark structure into the bookmarks file. */
FILE *
OpenTmpBookmarkFile(int nb)
{
FILE *outfp;
char pidStr[32];
char pathName[256], path2[256];
if (gOurDirectoryPath[0] == '\0')
return (NULL); /* Don't create in root directory. */
(void) OurDirectoryPath(path2, sizeof(path2), kBookmarkFileName);
(void) OurDirectoryPath(pathName, sizeof(pathName), kTmpBookmarkFileName);
(void) sprintf(pidStr, "-%u.txt", (unsigned int) getpid());
(void) STRNCAT(pathName, pidStr);
outfp = fopen(pathName, FOPEN_WRITE_TEXT);
if (outfp == NULL) {
(void) fprintf(stderr, "Could not save bookmark.\n");
perror(pathName);
return (NULL);
}
(void) _chmod(pathName, 00600);
if (nb > 0) {
if (fprintf(outfp, "NcFTP bookmark-file version: %d\nNumber of bookmarks: %d\n", kBookmarkVersion, nb) < 0) {
(void) fprintf(stderr, "Could not save bookmark.\n");
perror(pathName);
(void) fclose(outfp);
return (NULL);
}
} else {
if (fprintf(outfp, "NcFTP bookmark-file version: %d\nNumber of bookmarks: ??\n", kBookmarkVersion) < 0) {
(void) fprintf(stderr, "Could not save bookmark.\n");
perror(pathName);
(void) fclose(outfp);
return (NULL);
}
}
return (outfp);
} /* OpenTmpBookmarkFile */
static int format_insn_eflags_str( enum x86_flag_status flags, char *buf,
int len) {
static struct {
char *name;
int value;
} insn_flags[] = {
{ "carry_set ", 0x0001 },
{ "zero_set ", 0x0002 },
{ "oflow_set ", 0x0004 },
{ "dir_set ", 0x0008 },
{ "sign_set ", 0x0010 },
{ "parity_set ", 0x0020 },
{ "carry_or_zero_set ", 0x0040 },
{ "zero_set_or_sign_ne_oflow ", 0x0080 },
{ "carry_clear ", 0x0100 },
{ "zero_clear ", 0x0200 },
{ "oflow_clear ", 0x0400 },
{ "dir_clear ", 0x0800 },
{ "sign_clear ", 0x1000 },
{ "parity_clear ", 0x2000 },
{ "sign_eq_oflow ", 0x4000 },
{ "sign_ne_oflow ", 0x8000 },
{ NULL, 0x0000 }, //end
};
unsigned int i;
int len_orig = len;
for (i = 0; insn_flags[i].name; i++) {
if (! (flags & insn_flags[i].value) )
continue;
STRNCAT( buf, insn_flags[i].name, len );
}
return( len_orig - len );
}
/**
* @brief flushes the buffer
*
* This is the actual worker function. It opens the log file if it wasn't yet
* open, composes the addr2line commandline, pipes the buffer through it and
* writes the output of that - after some formatting - to the real logfile.
*/
void CLogger::FlushBuffer()
{
char buf1[4096], buf2[4096];
char* nl;
// Open logfile if it's not open.
if (!logfile) {
assert(filename);
if (!(logfile = fopen(filename, "a")))
return;
time_t t;
time(&t);
char* ct = ctime_r(&t, buf1);
if ((nl = strchr(ct, '\n'))) *nl = 0;
fprintf(logfile, "\n===> %s <===\n", ct);
}
// Get executable name if we didn't have it yet.
if (exename.empty()) {
get_executable_name(buf1, sizeof(buf1));
int len = strlen(buf1);
strncpy(buf2, buf1, sizeof(buf2));
buf2[sizeof(buf2)-1] = '\0'; // make sure the string is terminated
if (len > 4 && buf2[len-4] == '.')
buf2[len-4] = 0;
// Note: strncat: 3rd param: maximum number of characters to append
STRNCAT(buf2, ".dbg", sizeof(buf2) - strlen(buf2) - 1);
fprintf(logfile, "trying debug symbols file: '%s'\n", buf2);
struct stat tmp;
if (stat(buf2, &tmp) == 0) {
exename = buf2;
} else {
exename = buf1;
}
if (exename.empty())
return;
fprintf(logfile, "executable name: '%s'\n", exename.c_str());
}
// Compose addr2line command.
std::stringstream command;
std::vector<std::string>::iterator it;
bool runTheCommand = false;
command << ADDR2LINE << " \"--exe=" << exename << "\" --functions --demangle --inline";
for (it = buffer.begin(); it != buffer.end(); ++it) {
const int open = it->find('{');
const int close = it->find('}', open + 1);
if (open != std::string::npos && close != std::string::npos) {
command << " " << it->substr(open + 1, close - open - 1);
runTheCommand = true;
}
}
if (runTheCommand) {
// We got some addresses, so run the addr2line command.
// (This is usually the branch taken by the host)
fprintf(logfile, "addr2line command : '%s'\n", command.str().c_str());
// Open pipe to the addr2line command.
FILE* p = popen(command.str().c_str(), "r");
if (!p) {
fprintf(logfile, " %s\n", strerror(errno));
runTheCommand = false;
} else {
// Pipe the buffer through the addr2line command.
for (it = buffer.begin(); it != buffer.end(); ++it) {
const int open = it->find('{');
const int close = it->find('}', open + 1);
if (open != std::string::npos && close != std::string::npos) {
fgets(buf1, sizeof(buf1), p);
fgets(buf2, sizeof(buf2), p);
CppFilt(buf1, sizeof(buf1));
if ((nl = strchr(buf1, '\n'))) *nl = 0;
if ((nl = strchr(buf2, '\n'))) *nl = 0;
fprintf(logfile, "%s%s [%s]%s\n", it->substr(0, open).c_str(), buf1, buf2, it->substr(close + 1).c_str());
} else {
fprintf(logfile, "%s\n", it->c_str());
}
}
// Close pipe & clear buffer.
pclose(p);
}
}
if (!runTheCommand) {
// Just dump the buffer to the file.
// (this is usually the branch taken by the clients)
for (it = buffer.begin(); it != buffer.end(); ++it) {
fprintf(logfile, "%s\n", it->c_str());
}
}
buffer.clear();
}
/*
* Initialization routine for vim_findfile().
*
* Returns the newly allocated search context or NULL if an error occurred.
*
* Don't forget to clean up by calling vim_findfile_cleanup() if you are done
* with the search context.
*
* Find the file 'filename' in the directory 'path'.
* The parameter 'path' may contain wildcards. If so only search 'level'
* directories deep. The parameter 'level' is the absolute maximum and is
* not related to restricts given to the '**' wildcard. If 'level' is 100
* and you use '**200' vim_findfile() will stop after 100 levels.
*
* 'filename' cannot contain wildcards! It is used as-is, no backslashes to
* escape special characters.
*
* If 'stopdirs' is not NULL and nothing is found downward, the search is
* restarted on the next higher directory level. This is repeated until the
* start-directory of a search is contained in 'stopdirs'. 'stopdirs' has the
* format ";*<dirname>*\(;<dirname>\)*;\=$".
*
* If the 'path' is relative, the starting dir for the search is either VIM's
* current dir or if the path starts with "./" the current files dir.
* If the 'path' is absolute, the starting dir is that part of the path before
* the first wildcard.
*
* Upward search is only done on the starting dir.
*
* If 'free_visited' is TRUE the list of already visited files/directories is
* cleared. Set this to FALSE if you just want to search from another
* directory, but want to be sure that no directory from a previous search is
* searched again. This is useful if you search for a file at different places.
* The list of visited files/dirs can also be cleared with the function
* vim_findfile_free_visited().
*
* Set the parameter 'find_what' to FINDFILE_DIR if you want to search for
* directories only, FINDFILE_FILE for files only, FINDFILE_BOTH for both.
*
* A search context returned by a previous call to vim_findfile_init() can be
* passed in the parameter "search_ctx_arg". This context is reused and
* reinitialized with the new parameters. The list of already visited
* directories from this context is only deleted if the parameter
* "free_visited" is true. Be aware that the passed "search_ctx_arg" is freed
* if the reinitialization fails.
*
* If you don't have a search context from a previous call "search_ctx_arg"
* must be NULL.
*
* This function silently ignores a few errors, vim_findfile() will have
* limited functionality then.
*/
void *
vim_findfile_init (
char_u *path,
char_u *filename,
char_u *stopdirs,
int level,
int free_visited,
int find_what,
void *search_ctx_arg,
int tagfile, /* expanding names of tags files */
char_u *rel_fname /* file name to use for "." */
)
{
char_u *wc_part;
ff_stack_T *sptr;
ff_search_ctx_T *search_ctx;
/* If a search context is given by the caller, reuse it, else allocate a
* new one.
*/
if (search_ctx_arg != NULL)
search_ctx = search_ctx_arg;
else {
search_ctx = xcalloc(1, sizeof(ff_search_ctx_T));
}
search_ctx->ffsc_find_what = find_what;
search_ctx->ffsc_tagfile = tagfile;
/* clear the search context, but NOT the visited lists */
ff_clear(search_ctx);
/* clear visited list if wanted */
if (free_visited == TRUE)
vim_findfile_free_visited(search_ctx);
else {
/* Reuse old visited lists. Get the visited list for the given
* filename. If no list for the current filename exists, creates a new
* one. */
search_ctx->ffsc_visited_list = ff_get_visited_list(filename,
&search_ctx->ffsc_visited_lists_list);
if (search_ctx->ffsc_visited_list == NULL)
goto error_return;
search_ctx->ffsc_dir_visited_list = ff_get_visited_list(filename,
&search_ctx->ffsc_dir_visited_lists_list);
if (search_ctx->ffsc_dir_visited_list == NULL)
goto error_return;
}
if (ff_expand_buffer == NULL) {
ff_expand_buffer = xmalloc(MAXPATHL);
}
/* Store information on starting dir now if path is relative.
* If path is absolute, we do that later. */
if (path[0] == '.'
&& (vim_ispathsep(path[1]) || path[1] == NUL)
&& (!tagfile || vim_strchr(p_cpo, CPO_DOTTAG) == NULL)
&& rel_fname != NULL) {
int len = (int)(path_tail(rel_fname) - rel_fname);
if (!vim_isAbsName(rel_fname) && len + 1 < MAXPATHL) {
/* Make the start dir an absolute path name. */
STRLCPY(ff_expand_buffer, rel_fname, len + 1);
search_ctx->ffsc_start_dir = FullName_save(ff_expand_buffer, FALSE);
} else
search_ctx->ffsc_start_dir = vim_strnsave(rel_fname, len);
if (*++path != NUL)
++path;
} else if (*path == NUL || !vim_isAbsName(path)) {
#ifdef BACKSLASH_IN_FILENAME
/* "c:dir" needs "c:" to be expanded, otherwise use current dir */
if (*path != NUL && path[1] == ':') {
char_u drive[3];
drive[0] = path[0];
drive[1] = ':';
drive[2] = NUL;
if (vim_FullName(drive, ff_expand_buffer, MAXPATHL, TRUE) == FAIL)
goto error_return;
path += 2;
} else
#endif
if (os_dirname(ff_expand_buffer, MAXPATHL) == FAIL)
goto error_return;
search_ctx->ffsc_start_dir = vim_strsave(ff_expand_buffer);
#ifdef BACKSLASH_IN_FILENAME
/* A path that starts with "/dir" is relative to the drive, not to the
* directory (but not for "//machine/dir"). Only use the drive name. */
if ((*path == '/' || *path == '\\')
&& path[1] != path[0]
&& search_ctx->ffsc_start_dir[1] == ':')
search_ctx->ffsc_start_dir[2] = NUL;
#endif
}
/*
* If stopdirs are given, split them into an array of pointers.
* If this fails (mem allocation), there is no upward search at all or a
* stop directory is not recognized -> continue silently.
* If stopdirs just contains a ";" or is empty,
* search_ctx->ffsc_stopdirs_v will only contain a NULL pointer. This
* is handled as unlimited upward search. See function
* ff_path_in_stoplist() for details.
*/
if (stopdirs != NULL) {
char_u *walker = stopdirs;
int dircount;
while (*walker == ';')
walker++;
dircount = 1;
search_ctx->ffsc_stopdirs_v = xmalloc(sizeof(char_u *));
do {
char_u *helper;
void *ptr;
helper = walker;
ptr = xrealloc(search_ctx->ffsc_stopdirs_v,
(dircount + 1) * sizeof(char_u *));
search_ctx->ffsc_stopdirs_v = ptr;
walker = vim_strchr(walker, ';');
if (walker) {
search_ctx->ffsc_stopdirs_v[dircount-1] =
vim_strnsave(helper, (int)(walker - helper));
walker++;
} else
/* this might be "", which means ascent till top
* of directory tree.
*/
search_ctx->ffsc_stopdirs_v[dircount-1] =
vim_strsave(helper);
dircount++;
} while (walker != NULL);
search_ctx->ffsc_stopdirs_v[dircount-1] = NULL;
}
search_ctx->ffsc_level = level;
/* split into:
* -fix path
* -wildcard_stuff (might be NULL)
*/
wc_part = vim_strchr(path, '*');
if (wc_part != NULL) {
int llevel;
int len;
char *errpt;
/* save the fix part of the path */
search_ctx->ffsc_fix_path = vim_strnsave(path, (int)(wc_part - path));
/*
* copy wc_path and add restricts to the '**' wildcard.
* The octet after a '**' is used as a (binary) counter.
* So '**3' is transposed to '**^C' ('^C' is ASCII value 3)
* or '**76' is transposed to '**N'( 'N' is ASCII value 76).
* For EBCDIC you get different character values.
* If no restrict is given after '**' the default is used.
* Due to this technique the path looks awful if you print it as a
* string.
*/
len = 0;
while (*wc_part != NUL) {
if (len + 5 >= MAXPATHL) {
EMSG(_(e_pathtoolong));
break;
}
if (STRNCMP(wc_part, "**", 2) == 0) {
ff_expand_buffer[len++] = *wc_part++;
ff_expand_buffer[len++] = *wc_part++;
llevel = strtol((char *)wc_part, &errpt, 10);
if ((char_u *)errpt != wc_part && llevel > 0 && llevel < 255)
ff_expand_buffer[len++] = llevel;
else if ((char_u *)errpt != wc_part && llevel == 0)
/* restrict is 0 -> remove already added '**' */
len -= 2;
else
ff_expand_buffer[len++] = FF_MAX_STAR_STAR_EXPAND;
wc_part = (char_u *)errpt;
if (*wc_part != NUL && !vim_ispathsep(*wc_part)) {
EMSG2(_(
"E343: Invalid path: '**[number]' must be at the end of the path or be followed by '%s'."),
PATHSEPSTR);
goto error_return;
}
} else
ff_expand_buffer[len++] = *wc_part++;
}
ff_expand_buffer[len] = NUL;
search_ctx->ffsc_wc_path = vim_strsave(ff_expand_buffer);
} else
search_ctx->ffsc_fix_path = vim_strsave(path);
if (search_ctx->ffsc_start_dir == NULL) {
/* store the fix part as startdir.
* This is needed if the parameter path is fully qualified.
*/
search_ctx->ffsc_start_dir = vim_strsave(search_ctx->ffsc_fix_path);
search_ctx->ffsc_fix_path[0] = NUL;
}
/* create an absolute path */
if (STRLEN(search_ctx->ffsc_start_dir)
+ STRLEN(search_ctx->ffsc_fix_path) + 3 >= MAXPATHL) {
EMSG(_(e_pathtoolong));
goto error_return;
}
STRCPY(ff_expand_buffer, search_ctx->ffsc_start_dir);
add_pathsep(ff_expand_buffer);
{
size_t eb_len = STRLEN(ff_expand_buffer);
char_u *buf = xmalloc(eb_len + STRLEN(search_ctx->ffsc_fix_path) + 1);
STRCPY(buf, ff_expand_buffer);
STRCPY(buf + eb_len, search_ctx->ffsc_fix_path);
if (os_isdir(buf)) {
STRCAT(ff_expand_buffer, search_ctx->ffsc_fix_path);
add_pathsep(ff_expand_buffer);
} else {
char_u *p = path_tail(search_ctx->ffsc_fix_path);
char_u *wc_path = NULL;
char_u *temp = NULL;
int len = 0;
if (p > search_ctx->ffsc_fix_path) {
len = (int)(p - search_ctx->ffsc_fix_path) - 1;
STRNCAT(ff_expand_buffer, search_ctx->ffsc_fix_path, len);
add_pathsep(ff_expand_buffer);
} else
len = (int)STRLEN(search_ctx->ffsc_fix_path);
if (search_ctx->ffsc_wc_path != NULL) {
wc_path = vim_strsave(search_ctx->ffsc_wc_path);
temp = xmalloc(STRLEN(search_ctx->ffsc_wc_path)
+ STRLEN(search_ctx->ffsc_fix_path + len)
+ 1);
}
if (temp == NULL || wc_path == NULL) {
free(buf);
free(temp);
free(wc_path);
goto error_return;
}
STRCPY(temp, search_ctx->ffsc_fix_path + len);
STRCAT(temp, search_ctx->ffsc_wc_path);
free(search_ctx->ffsc_wc_path);
free(wc_path);
search_ctx->ffsc_wc_path = temp;
}
free(buf);
}
sptr = ff_create_stack_element(ff_expand_buffer,
search_ctx->ffsc_wc_path,
level, 0);
ff_push(search_ctx, sptr);
search_ctx->ffsc_file_to_search = vim_strsave(filename);
return search_ctx;
error_return:
/*
* We clear the search context now!
* Even when the caller gave us a (perhaps valid) context we free it here,
* as we might have already destroyed it.
*/
vim_findfile_cleanup(search_ctx);
return NULL;
}
int
UnMlsD(const FTPCIPtr cip, FTPFileInfoListPtr filp, FTPLineListPtr llp)
{
MLstItem mli;
char plug[64];
char og[32];
int rc;
FTPLinePtr lp;
FTPFileInfo fi;
int linesread = 0;
int linesconverted = 0;
int linesignored = 0;
size_t maxFileLen = 0;
size_t maxPlugLen = 0;
size_t fileLen, plugLen;
int m1, m2, m3;
const char *cm1, *cm2, *cm3;
InitFileInfoList(filp);
for (lp = llp->first; lp != NULL; lp = lp->next) {
linesread++;
rc = UnMlsT(cip, lp->line, &mli);
if (rc == 0) {
if (PathContainsIntermediateDotDotSubDir(mli.fname)) {
linesignored++;
continue;
}
fileLen = strlen(mli.fname);
linesconverted++;
if (fileLen > maxFileLen)
maxFileLen = fileLen;
fi.relnameLen = fileLen;
fi.relname = StrDup(mli.fname);
fi.rname = NULL;
fi.lname = NULL;
fi.rlinkto = (mli.linkto[0] == '\0') ? NULL : StrDup(mli.linkto);
fi.mdtm = mli.ftime;
fi.size = (longest_int) mli.fsize;
fi.type = mli.ftype;
fi.mode = -1;
plug[0] = (char) mli.ftype;
plug[1] = '\0';
m1 = 0;
m2 = 0;
m3 = -1;
if (mli.mode != (-1)) {
fi.mode = mli.mode;
m1 = (mli.mode & 00700) >> 6;
m2 = (mli.mode & 00070) >> 3;
m3 = (mli.mode & 00007);
}
if (mli.perm[0] != '\0') {
m3 = 0;
if (fi.type == 'd') {
if (strchr(mli.perm, 'e') != NULL) {
/* execute -> execute */
m3 |= 00001;
}
if (strchr(mli.perm, 'c') != NULL) {
/* create -> write */
m3 |= 00002;
}
if (strchr(mli.perm, 'l') != NULL) {
/* list -> read */
m3 |= 00004;
}
} else {
if (strchr(mli.perm, 'w') != NULL) {
/* write -> write */
m3 |= 00002;
}
if (strchr(mli.perm, 'r') != NULL) {
/* read -> read */
m3 |= 00004;
}
}
}
if (m3 != (-1)) {
cm1 = rwx[m1];
cm2 = rwx[m2];
cm3 = rwx[m3];
sprintf(plug + 1, "%s%s%s", cm1, cm2, cm3);
}
if (mli.owner[0] != '\0') {
if (mli.group[0] != '\0') {
#ifdef HAVE_SNPRINTF
snprintf(og, sizeof(og) - 1,
#else
sprintf(og,
#endif /* HAVE_SNPRINTF */
" %-8.8s %s",
mli.owner, mli.group
);
STRNCAT(plug, og);
} else {
STRNCAT(plug, " ");
STRNCAT(plug, mli.owner);
}
}
static int format_operand_raw( x86_op_t *op, x86_insn_t *insn, char *buf,
int len){
char str[MAX_OP_RAW_STRING];
char *datatype = get_operand_datatype_str(op);
switch (op->type) {
case op_register:
get_operand_regtype_str( op->data.reg.type, str,
sizeof str );
STRNCAT( buf, "reg|", len );
STRNCATF( buf, "%s|", datatype, len );
STRNCATF( buf, "%s:", op->data.reg.name, len );
STRNCATF( buf, "%s:", str, len );
STRNCATF( buf, "%d|", op->data.reg.size, len );
break;
case op_immediate:
get_operand_data_str( op, str, sizeof str );
STRNCAT( buf, "immediate|", len );
STRNCATF( buf, "%s|", datatype, len );
STRNCATF( buf, "%s|", str, len );
break;
case op_relative_near:
/* NOTE: in raw format, we print the
* relative offset, not the actual
* address of the jump target */
STRNCAT( buf, "relative|", len );
STRNCATF( buf, "%s|", datatype, len );
STRNCATF( buf, "%hhd|", op->data.sbyte, len );
break;
case op_relative_far:
STRNCAT( buf, "relative|", len );
STRNCATF( buf, "%s|", datatype, len );
if (op->datatype == op_word) {
STRNCATF( buf, "%hd|", op->data.sword, len);
break;
} else {
STRNCATF( buf, "%d|", op->data.sdword, len );
}
break;
case op_absolute:
STRNCAT( buf, "absolute_address|", len );
STRNCATF( buf, "%s|", datatype, len );
STRNCATF( buf, "$0x%04hX:", op->data.absolute.segment,
len );
if (op->datatype == op_descr16) {
STRNCATF( buf, "0x%04hX|",
op->data.absolute.offset.off16, len );
} else {
STRNCATF( buf, "0x%08X|",
op->data.absolute.offset.off32, len );
}
break;
case op_expression:
STRNCAT( buf, "address_expression|", len );
STRNCATF( buf, "%s|", datatype, len );
len -= format_seg( op, buf, len, native_syntax );
len -= format_expr( &op->data.expression, buf, len,
raw_syntax );
STRNCAT( buf, "|", len );
break;
case op_offset:
STRNCAT( buf, "segment_offset|", len );
STRNCATF( buf, "%s|", datatype, len );
len -= format_seg( op, buf, len, xml_syntax );
STRNCATF( buf, "%08X|", op->data.sdword, len );
break;
case op_unused:
case op_unknown:
/* return 0-truncated buffer */
break;
}
return( strlen( buf ) );
}
static int format_operand_xml( x86_op_t *op, x86_insn_t *insn, char *buf,
int len){
char str[MAX_OP_STRING] = "\0";
switch (op->type) {
case op_register:
get_operand_regtype_str( op->data.reg.type, str,
sizeof str );
STRNCAT( buf, "\t\t<register ", len );
STRNCATF( buf, "name=\"%s\" ", op->data.reg.name, len );
STRNCATF( buf, "type=\"%s\" ", str, len );
STRNCATF( buf, "size=%d/>\n", op->data.reg.size, len );
break;
case op_immediate:
get_operand_data_str( op, str, sizeof str );
STRNCAT( buf, "\t\t<immediate ", len );
STRNCATF( buf, "type=\"%s\" ",
get_operand_datatype_str (op), len );
STRNCATF( buf, "value=\"%s\"/>\n", str, len );
break;
case op_relative_near:
STRNCAT( buf, "\t\t<relative_offset ", len );
STRNCATF( buf, "value=\"0x%08X\"/>\n",
(unsigned int)(op->data.sbyte +
insn->addr + insn->size), len );
break;
case op_relative_far:
STRNCAT( buf, "\t\t<relative_offset ", len );
if (op->datatype == op_word) {
STRNCATF( buf, "value=\"0x%08X\"/>\n",
(unsigned int)(op->data.sword +
insn->addr + insn->size), len);
break;
} else {
STRNCATF( buf, "value=\"0x%08X\"/>\n",
op->data.sdword + insn->addr + insn->size,
len );
}
break;
case op_absolute:
STRNCATF( buf,
"\t\t<absolute_address segment=\"0x%04hX\"",
op->data.absolute.segment, len );
if (op->datatype == op_descr16) {
STRNCATF( buf, "offset=\"0x%04hX\">",
op->data.absolute.offset.off16, len );
} else {
STRNCATF( buf, "offset=\"0x%08X\">",
op->data.absolute.offset.off32, len );
}
STRNCAT( buf, "\t\t</absolute_address>\n", len );
break;
case op_expression:
STRNCAT( buf, "\t\t<address_expression>\n", len );
len -= format_seg( op, buf, len, xml_syntax );
len -= format_expr( &op->data.expression, buf, len,
xml_syntax );
STRNCAT( buf, "\t\t</address_expression>\n", len );
break;
case op_offset:
STRNCAT( buf, "\t\t<segment_offset>\n", len );
len -= format_seg( op, buf, len, xml_syntax );
STRNCAT( buf, "\t\t\t<address ", len);
STRNCATF( buf, "value=\"0x%08X\"/>\n",
op->data.sdword, len );
STRNCAT( buf, "\t\t</segment_offset>\n", len );
break;
case op_unused:
case op_unknown:
/* return 0-truncated buffer */
break;
}
return( strlen( buf ) );
}
static int format_expr( x86_ea_t *ea, char *buf, int len,
enum x86_asm_format format ) {
char str[MAX_OP_STRING];
if ( format == att_syntax ) {
if (ea->base.name[0] || ea->index.name[0] || ea->scale) {
PRINT_DISPLACEMENT(ea);
STRNCAT( buf, "(", len );
if ( ea->base.name[0]) {
STRNCATF( buf, "%%%s", ea->base.name, len );
}
if ( ea->index.name[0]) {
STRNCATF( buf, ",%%%s", ea->index.name, len );
if ( ea->scale > 1 ) {
STRNCATF( buf, ",%d", ea->scale, len );
}
}
/* handle the syntactic exception */
if ( ! ea->base.name[0] &&
! ea->index.name[0] ) {
STRNCATF( buf, ",%d", ea->scale, len );
}
STRNCAT( buf, ")", len );
} else
STRNCATF( buf, "0x%X", ea->disp, len );
} else if ( format == xml_syntax ){
if ( ea->base.name[0]) {
STRNCAT (buf, "\t\t\t<base>\n", len);
get_operand_regtype_str (ea->base.type, str,
sizeof str);
STRNCAT (buf, "\t\t\t\t<register ", len);
STRNCATF (buf, "name=\"%s\" ", ea->base.name, len);
STRNCATF (buf, "type=\"%s\" ", str, len);
STRNCATF (buf, "size=%d/>\n", ea->base.size, len);
STRNCAT (buf, "\t\t\t</base>\n", len);
}
if ( ea->index.name[0]) {
STRNCAT (buf, "\t\t\t<index>\n", len);
get_operand_regtype_str (ea->index.type, str,
sizeof str);
STRNCAT (buf, "\t\t\t\t<register ", len);
STRNCATF (buf, "name=\"%s\" ", ea->index.name, len);
STRNCATF (buf, "type=\"%s\" ", str, len);
STRNCATF (buf, "size=%d/>\n", ea->index.size, len);
STRNCAT (buf, "\t\t\t</index>\n", len);
}
//scale
STRNCAT (buf, "\t\t\t<scale>\n", len);
STRNCAT (buf, "\t\t\t\t<immediate ", len);
STRNCATF (buf, "value=\"%d\"/>\n", ea->scale, len);
STRNCAT (buf, "\t\t\t</scale>\n", len);
if ( ea->disp_size ) {
STRNCAT (buf, "\t\t\t<displacement>\n", len);
if ( ea->disp_size > 1 && ! ea->disp_sign ) {
STRNCAT (buf, "\t\t\t\t<address ", len);
STRNCATF (buf, "value=\"0x%X" "\"/>\n", ea->disp,
len);
} else {
STRNCAT (buf, "\t\t\t\t<immediate ", len);
STRNCATF (buf, "value=%d" "/>\n", ea->disp, len);
}
STRNCAT (buf, "\t\t\t</displacement>\n", len);
}
} else if ( format == raw_syntax ) {
PRINT_DISPLACEMENT(ea);
STRNCAT( buf, "(", len );
STRNCATF( buf, "%s,", ea->base.name, len );
STRNCATF( buf, "%s,", ea->index.name, len );
STRNCATF( buf, "%d", ea->scale, len );
STRNCAT( buf, ")", len );
} else {
STRNCAT( buf, "[", len );
if ( ea->base.name[0] ) {
STRNCAT( buf, ea->base.name, len );
if ( ea->index.name[0] ||
(ea->disp_size && ! ea->disp_sign) ) {
STRNCAT( buf, "+", len );
}
}
if ( ea->index.name[0] ) {
STRNCAT( buf, ea->index.name, len );
if ( ea->scale > 1 )
{
STRNCATF( buf, "*%d", ea->scale, len );
}
if ( ea->disp_size && ! ea->disp_sign )
{
STRNCAT( buf, "+", len );
}
}
if ( ea->disp_size || (! ea->index.name[0] &&
! ea->base.name[0] ) )
{
PRINT_DISPLACEMENT(ea);
}
STRNCAT( buf, "]", len );
}
return( strlen(buf) );
}
int x86_format_insn( x86_insn_t *insn, char *buf, int len,
enum x86_asm_format format ){
char str[MAX_OP_STRING];
x86_op_t *src, *dst;
int i;
memset(buf, 0, len);
if ( format == intel_syntax ) {
/* INTEL STYLE: mnemonic dest, src, imm */
STRNCAT( buf, insn->prefix_string, len );
STRNCAT( buf, insn->mnemonic, len );
STRNCAT( buf, "\t", len );
/* dest */
if ( (dst = x86_operand_1st( insn )) && !(dst->flags & op_implied) ) {
x86_format_operand( dst, str, MAX_OP_STRING, format);
STRNCAT( buf, str, len );
}
/* src */
if ( (src = x86_operand_2nd( insn )) ) {
if ( !(dst->flags & op_implied) ) {
STRNCAT( buf, ", ", len );
}
x86_format_operand( src, str, MAX_OP_STRING, format);
STRNCAT( buf, str, len );
}
/* imm */
if ( x86_operand_3rd( insn )) {
STRNCAT( buf, ", ", len );
x86_format_operand( x86_operand_3rd( insn ),
str, MAX_OP_STRING, format);
STRNCAT( buf, str, len );
}
} else if ( format == att_syntax ) {
/* ATT STYLE: mnemonic src, dest, imm */
STRNCAT( buf, insn->prefix_string, len );
format_att_mnemonic(insn, str, MAX_OP_STRING);
STRNCATF( buf, "%s\t", str, len);
/* not sure which is correct? sometimes GNU as requires
* an imm as the first operand, sometimes as the third... */
/* imm */
if ( x86_operand_3rd( insn ) ) {
x86_format_operand(x86_operand_3rd( insn ),
str, MAX_OP_STRING, format);
STRNCAT( buf, str, len );
/* there is always 'dest' operand if there is 'src' */
STRNCAT( buf, ", ", len );
}
if ( (insn->note & insn_note_nonswap ) == 0 ) {
/* regular AT&T style swap */
src = x86_operand_2nd( insn );
dst = x86_operand_1st( insn );
}
else {
/* special-case instructions */
src = x86_operand_1st( insn );
dst = x86_operand_2nd( insn );
}
/* src */
if ( src ) {
x86_format_operand(src, str, MAX_OP_STRING, format);
STRNCAT( buf, str, len );
/* there is always 'dest' operand if there is 'src' */
if ( dst && !(dst->flags & op_implied) ) {
STRNCAT( buf, ", ", len );
}
}
/* dest */
if ( dst && !(dst->flags & op_implied) ) {
x86_format_operand( dst, str, MAX_OP_STRING, format);
STRNCAT( buf, str, len );
}
} else if ( format == raw_syntax ) {
format_raw_insn( insn, buf, len );
} else if ( format == xml_syntax ) {
format_xml_insn( insn, buf, len );
} else { /* default to native */
/* NATIVE style: RVA\tBYTES\tMNEMONIC\tOPERANDS */
/* print address */
STRNCATF( buf, "%08X\t", insn->addr, len );
/* print bytes */
for ( i = 0; i < insn->size; i++ ) {
STRNCATF( buf, "%02X ", insn->bytes[i], len );
}
STRNCAT( buf, "\t", len );
/* print mnemonic */
STRNCAT( buf, insn->prefix_string, len );
STRNCAT( buf, insn->mnemonic, len );
STRNCAT( buf, "\t", len );
/* print operands */
/* dest */
if ( x86_operand_1st( insn ) ) {
x86_format_operand( x86_operand_1st( insn ),
str, MAX_OP_STRING, format);
STRNCATF( buf, "%s\t", str, len );
}
/* src */
if ( x86_operand_2nd( insn ) ) {
x86_format_operand(x86_operand_2nd( insn ),
str, MAX_OP_STRING, format);
STRNCATF( buf, "%s\t", str, len );
}
/* imm */
if ( x86_operand_3rd( insn )) {
x86_format_operand( x86_operand_3rd( insn ),
str, MAX_OP_STRING, format);
STRNCAT( buf, str, len );
}
}
return( strlen( buf ) );
}
static int format_xml_insn( x86_insn_t *insn, char *buf, int len ) {
char str[MAX_OP_XML_STRING];
int i;
STRNCAT( buf, "<x86_insn>\n", len );
STRNCATF( buf, "\t<address rva=\"0x%08X\" ", insn->addr, len );
STRNCATF( buf, "offset=\"0x%08X\" ", insn->offset, len );
STRNCATF( buf, "size=%d bytes=\"", insn->size, len );
for ( i = 0; i < insn->size; i++ ) {
STRNCATF( buf, "%02X ", insn->bytes[i], len );
}
STRNCAT( buf, "\"/>\n", len );
STRNCAT( buf, "\t<prefix type=\"", len );
len -= format_insn_prefix_str( insn->prefix, buf, len );
STRNCATF( buf, "\" string=\"%s\"/>\n", insn->prefix_string, len );
STRNCATF( buf, "\t<mnemonic group=\"%s\" ",
get_insn_group_str (insn->group), len );
STRNCATF( buf, "type=\"%s\" ", get_insn_type_str (insn->type), len );
STRNCATF( buf, "string=\"%s\"/>\n", insn->mnemonic, len );
STRNCAT( buf, "\t<flags type=set>\n", len );
STRNCAT( buf, "\t\t<flag name=\"", len );
len -= format_insn_eflags_str( insn->flags_set, buf, len );
STRNCAT( buf, "\"/>\n\t</flags>\n", len );
STRNCAT( buf, "\t<flags type=tested>\n", len );
STRNCAT( buf, "\t\t<flag name=\"", len );
len -= format_insn_eflags_str( insn->flags_tested, buf, len );
STRNCAT( buf, "\"/>\n\t</flags>\n", len );
if ( x86_operand_1st( insn ) ) {
x86_format_operand( x86_operand_1st(insn), str,
sizeof str, xml_syntax);
STRNCAT( buf, "\t<operand name=dest>\n", len );
STRNCAT( buf, str, len );
STRNCAT( buf, "\t</operand>\n", len );
}
if ( x86_operand_2nd( insn ) ) {
x86_format_operand( x86_operand_2nd( insn ), str,
sizeof str, xml_syntax);
STRNCAT( buf, "\t<operand name=src>\n", len );
STRNCAT( buf, str, len );
STRNCAT( buf, "\t</operand>\n", len );
}
if ( x86_operand_3rd( insn ) ) {
x86_format_operand( x86_operand_3rd(insn), str,
sizeof str, xml_syntax);
STRNCAT( buf, "\t<operand name=imm>\n", len );
STRNCAT( buf, str, len );
STRNCAT( buf, "\t</operand>\n", len );
}
STRNCAT( buf, "</x86_insn>\n", len );
return strlen (buf);
}
/*
* read odbc init file to resolve the value of specified
* key from named or defaulted dsn section
*/
char *
_iodbcdm_getkeyvalbydsn (
char *dsn,
int dsnlen,
char *keywd,
char *value,
int size)
{
char buf[1024];
char dsntk[SQL_MAX_DSN_LENGTH + 3] = {'[', '\0'};
char token[1024]; /* large enough */
FILE *file;
char pathbuf[1024];
char *path;
#define DSN_NOMATCH 0
#define DSN_NAMED 1
#define DSN_DEFAULT 2
int dsnid = DSN_NOMATCH;
int defaultdsn = DSN_NOMATCH;
if (dsn == NULL || *dsn == 0)
{
dsn = "default";
dsnlen = STRLEN (dsn);
}
if (dsnlen == SQL_NTS)
{
dsnlen = STRLEN (dsn);
}
if (dsnlen <= 0 || keywd == NULL || buf == 0 || size <= 0)
{
return NULL;
}
if (dsnlen > sizeof (dsntk) - 2)
{
return NULL;
}
value[0] = '\0';
STRNCAT (dsntk, dsn, dsnlen);
STRCAT (dsntk, "]");
dsnlen = dsnlen + 2;
path = _iodbcdm_getinifile (pathbuf, sizeof (pathbuf));
if (path == NULL)
{
return NULL;
}
file = (FILE *) fopen (path, "r");
if (file == NULL)
{
return NULL;
}
for (;;)
{
char *str;
str = fgets (buf, sizeof (buf), file);
if (str == NULL)
{
break;
}
if (*str == '[')
{
if (upper_strneq (str, "[default]", STRLEN ("[default]")))
{
/* we only read first dsn default dsn
* section (as well as named dsn).
*/
if (defaultdsn == DSN_NOMATCH)
{
dsnid = DSN_DEFAULT;
defaultdsn = DSN_DEFAULT;
}
else
{
dsnid = DSN_NOMATCH;
}
continue;
}
else if (upper_strneq (str, dsntk, dsnlen))
{
dsnid = DSN_NAMED;
}
else
{
dsnid = DSN_NOMATCH;
}
continue;
}
else if (dsnid == DSN_NOMATCH)
{
continue;
}
str = readtoken (str, token);
if (upper_strneq (keywd, token, STRLEN (keywd)))
{
str = readtoken (str, token);
if (!STREQ (token, "="))
/* something other than = */
{
continue;
}
str = readtoken (str, token);
if (STRLEN (token) > size - 1)
{
break;
}
STRNCPY (value, token, size);
/* copy the value(i.e. next token) to buf */
if (dsnid != DSN_DEFAULT)
{
break;
}
}
}
fclose (file);
return (*value) ? value : NULL;
}
static char *
RemoteCompletionFunction(const char *text, int state, int fTypeFilter)
{
char rpath[256];
char *cp;
char *cp2;
const char *textbasename;
int fType;
FileInfoPtr diritemp;
FileInfoListPtr filp;
int textdirlen;
size_t tbnlen;
size_t flen, mlen;
static FileInfoVec diritemv;
static int i;
textbasename = strrchr(text, '/');
if (textbasename == NULL) {
textbasename = text;
textdirlen = -1;
} else {
textdirlen = (int) (textbasename - text);
textbasename++;
}
tbnlen = strlen(textbasename);
if (state == 0) {
if (text[0] == '\0') {
/* Special case when they do "get <TAB><TAB> " */
STRNCPY(rpath, gRemoteCWD);
} else {
PathCat(rpath, sizeof(rpath), gRemoteCWD, text);
if (text[strlen(text) - 1] == '/') {
/* Special case when they do "get /dir1/dir2/<TAB><TAB>" */
STRNCAT(rpath, "/");
}
cp2 = strrchr(rpath, '/');
if (cp2 == NULL) {
return NULL;
} else if (cp2 == rpath) {
/* Item in root directory. */
cp2++;
}
*cp2 = '\0';
}
filp = GetLsCacheFileList(rpath);
if (filp == NULL)
return NULL;
diritemv = filp->vec;
if (diritemv == NULL)
return NULL;
i = 0;
}
for ( ; ; ) {
diritemp = diritemv[i];
if (diritemp == NULL)
break;
i++;
fType = (int) diritemp->type;
if ((fTypeFilter == 0) || (fType == fTypeFilter) || (fType == /* symlink */ 'l')) {
if (strncmp(textbasename, diritemp->relname, tbnlen) == 0) {
flen = strlen(diritemp->relname);
if (textdirlen < 0) {
mlen = flen + 2;
cp = (char *) malloc(mlen);
if (cp == NULL)
return (NULL);
(void) memcpy(cp, diritemp->relname, mlen);
} else {
mlen = textdirlen + 1 + flen + 2;
cp = (char *) malloc(mlen);
if (cp == NULL)
return (NULL);
(void) memcpy(cp, text, (size_t) textdirlen);
cp[textdirlen] = '/';
(void) strcpy(cp + textdirlen + 1, diritemp->relname);
}
if (fType == 'd') {
gl_completion_exact_match_extra_char = '/';
} else {
gl_completion_exact_match_extra_char = ' ';
}
return cp;
}
}
}
return NULL;
} /* RemoteCompletionFunction */
void
GetScreenColumns(void)
{
#if defined(WIN32) || defined(_WINDOWS)
CONSOLE_SCREEN_BUFFER_INFO csbi;
if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi)) {
gScreenColumns = (int) csbi.dwSize.X;
if (gScreenColumns < 80)
gScreenColumns = 80;
}
#else /* Unix */
#ifdef BINDIR
char ncftpbookmarks[256];
FILE *infp;
vsigproc_t osigpipe;
int columns;
#endif /* BINDIR */
char *cp;
if ((cp = (char *) getenv("COLUMNS")) == NULL) {
gScreenColumns = 80;
} else {
gScreenColumns = atoi(cp);
return;
}
#ifdef TIOCGWINSZ
{
struct winsize felix;
memset(&felix, 0, sizeof(felix));
if (ioctl(0, TIOCGWINSZ, &felix) == 0) {
columns = felix.ws_col;
if ((columns > 0) && (columns < GL_BUF_SIZE))
gScreenColumns = columns;
else
gScreenColumns = 80;
return;
}
}
#endif
#ifdef BINDIR
/* Don't run things as root unless really necessary. */
if (gUid == 0)
return;
/* This is a brutal hack where we've hacked a
* special command line option into ncftp_bookmarks
* (which is linked with curses) so that it computes
* the screen size and prints it to stdout.
*
* This function runs ncftp_bookmarks and gets
* that information. The reason we do this is that
* we may or may not have a sane installation of
* curses/termcap, and we don't want to increase
* NcFTP's complexity by the curses junk just to
* get the screen size. Instead, we delegate this
* to ncftp_bookmarks which already deals with the
* ugliness of curses.
*/
STRNCPY(ncftpbookmarks, BINDIR);
STRNCAT(ncftpbookmarks, "/");
STRNCAT(ncftpbookmarks, "ncftpbookmarks");
if (access(ncftpbookmarks, X_OK) < 0)
return;
STRNCAT(ncftpbookmarks, " --dimensions-terse");
osigpipe = NcSignal(SIGPIPE, SIG_IGN);
infp = popen(ncftpbookmarks, "r");
if (infp != NULL) {
columns = 0;
(void) fscanf(infp, "%d", &columns);
while (getc(infp) != EOF) {}
(void) pclose(infp);
if ((columns > 0) && (columns < GL_BUF_SIZE))
gScreenColumns = columns;
}
(void) NcSignal(SIGPIPE, (sigproc_t) osigpipe);
#endif /* BINDIR */
#endif /* Windows */
} /* GetScreenColumns */
