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 */