void getmalloc_conf() { extern malloc_conf myconf; char buffer[4096]; int len_read; register int i_buffer; int i_conf; if ((len_read = getconffile(buffer)) == -1) return ; for (i_buffer = 0; i_buffer < len_read; ++i_buffer) { i_conf = 0; while (confmalloc[i_conf].name && !strfind(buffer + i_buffer, confmalloc[i_conf].name)) ++i_conf; if (confmalloc[i_conf].name) { i_buffer += confmalloc[i_conf].len_name; if (confmalloc[i_conf].nbr) { myconf.info |= confmalloc[i_conf].byte; *(confmalloc[i_conf].nbr) = get_nbr(buffer + i_buffer, '\n'); } else if (strfind(buffer + i_buffer, "yes")) myconf.info |= confmalloc[i_conf].byte; } while (buffer[i_buffer] != '\n' && i_buffer < len_read) ++i_buffer; } }
int main(int argc, char* argv[]) { for (int i = 0; i < RSN_ENTRIES; i++) { rsnEntries[i] = NULL; rsnSize[i] = 0; } rsnInfo = NULL; resetRsnEntries(); printf("\nUnrar Into Memory Learn 1.0\n\n"); rarFileData.ArcName = "test.rar"; rarFileData.OpenMode = RAR_OM_EXTRACT; rarHandle = RAROpenArchive(&rarFileData); printf("Opening test.rar: %d\n", rarFileData.OpenResult); if (rarFileData.OpenResult == ERAR_SUCCESS) { printf("-->Success\n"); int res = RARReadHeader(rarHandle, &rarFileHeader); while(res == ERAR_SUCCESS) { printf("Header '%s' -> %d -> %d Bytes\n", rarFileHeader.FileName, res, rarFileHeader.UnpSize); if (strfind(rarFileHeader.FileName, ".spc") != NULL && rsnCount < RSN_ENTRIES && rarFileHeader.UnpSize > 66000 && rarFileHeader.UnpSize < 67000) { printf("--> SPC File, going to extract\n"); rsnEntries[rsnCount] = (char*)malloc(rarFileHeader.UnpSize); if (rsnEntries[rsnCount] != NULL) { printf("--> Pointer to memory: %p\n", rsnEntries[rsnCount]); RARSetCallback(rarHandle, rarExtractSpcBytes, (long)rsnEntries[rsnCount]); RARProcessFile(rarHandle, RAR_EXTRACT, NULL, NULL); rsnSize[rsnCount] = rarFileHeader.UnpSize; rsnCount++; } } else if (strfind(rarFileHeader.FileName, ".txt") != NULL && rsnInfo == NULL && rarFileHeader.UnpSize < 10000) { printf("--> TXT File, going to extract\n"); rsnInfo = (char*)calloc(rarFileHeader.UnpSize + 1, 1); if (rsnInfo != NULL) { RARSetCallback(rarHandle, rarExtractInfoBytes, (long)rsnInfo); RARProcessFile(rarHandle, RAR_EXTRACT, NULL, NULL); } } else { printf("--> Skip\n"); RARProcessFile(rarHandle, RAR_SKIP, NULL, NULL); } res = RARReadHeader(rarHandle, &rarFileHeader); } printf("Result: %d\n", res); } RARCloseArchive(rarHandle); printf("Tracks: %d\n", rsnCount); printf("Info: %d\n\n%s\n", rsnInfo == NULL ? 0 : strlen(rsnInfo), rsnInfo == NULL ? "<?>" : rsnInfo); return 0; }
/* Remove all instances of substring ss in string s, modifying s in place. */ void CleanString(char *s, const char *ss) { size_t sslen = strlen(ss); char *fs = (char*) strfind(s, ss); while (fs != NULL) { do { fs[0] = fs[sslen]; fs++; } while (*fs != '\0'); fs = (char*) strfind(s, ss); } }
/** * takes a string that is a supposed file path, and * checks for certian wildcards ( like ~ for home directory ) * and resolves to an actual absolute path. **/ dstrbuf * expandPath(const char *path) { struct passwd *pw = NULL; dstrbuf *tmp = DSB_NEW; dstrbuf *ret = DSB_NEW; dsbCopy(tmp, path); if (tmp->len > 0 && tmp->str[0] == '&') { dsbCopy(ret, EMAIL_DIR); } else if (tmp->len > 0 && tmp->str[0] == '~') { if (tmp->str[1] == '/') { pw = getpwuid(getuid()); } else { int pos = strfind(tmp->str, '/'); if (pos >= 0) { char *p = substr(tmp->str, 1, pos-1); if (p) { pw = getpwnam(p); xfree(p); } } if (!pw) { pw = getpwuid(getuid()); } } if (pw) { dsbCopy(ret, pw->pw_dir); } } if (ret->len > 0) { int pos = strfind(tmp->str, '/'); if (pos > 0) { char *p = substr(tmp->str, pos, tmp->len); if (p) { dsbCat(ret, p); xfree(p); } } } else { dsbCopy(ret, path); } dsbDestroy(tmp); return ret; }
int mbus_addr_match(const char *a, const char *b) { /* Compare the addresses "a" and "b". These may optionally be */ /* surrounded by "(" and ")" and may have an arbitrary amount */ /* of white space between components of the addresses. There */ /* is a match if every word of address b is in address a. */ const char *y = NULL; assert(a != NULL); assert(b != NULL); /* Skip leading whitespace and '('... */ while (isspace((unsigned char)*a) || (*a == '(')) a++; while (isspace((unsigned char)*b) || (*b == '(')) b++; while ((*b != '\0') && (*b != ')')) { /* Move b along through the string to the start of the next */ /* word. Move y along from that to the end of the word. */ while (isspace((unsigned char)*b)) b++; for (y = b; ((*y != ' ') && (*y != ')') && (*y != '\0')); y++) { /* do nothing */ } if(y == b) return TRUE; y--; /* Check if the word between b and y is contained in the */ /* string pointed to be a. */ if (!strfind(a, b, y)) { return FALSE; } b = ++y; } return TRUE; }
/* Get To tag */ static str getToAddress(struct sip_msg *msg) { static char buf[16] = "unknown"; // buf is here for a reason. don't static str notfound = {buf, 7}; // use the constant string directly! str uri; char *ptr; if (!msg->to) { LOG(L_ERR, "error: mediaproxy/getToAddress(): missing To: field\n"); return notfound; } uri = get_to(msg)->uri; if (uri.len == 0) return notfound; if (strncmp(uri.s, "sip:", 4)==0) { uri.s += 4; uri.len -= 4; } if ((ptr = strfind(uri.s, uri.len, ";", 1))!=NULL) { uri.len = ptr - uri.s; } return uri; }
int main(int argc, char *argv[]) { int debug; char *s1, *s2, *s3; s1 = readLine(); s2 = readLine(); debug = letter_qnt(s1); printf("s1 size = %d\n", debug); debug = letter_qnt(s2); printf("s2 size = %d\n", debug); debug = strfind(s1, s2); printf("S1 is found? %d\n", debug); debug = strcmp(s1, s2); printf("Comparison: %d\n", debug); s3 = strcat(s1, s2); debug = letter_qnt(s3); printf("New string: %s\nNew string size: %d\n", s3, debug); erase(s1); erase(s2); erase(s3); return 0; }
static str getFromAddress(struct sip_msg *msg) { static char buf[16] = "unknown"; // buf is here for a reason. don't static str notfound = {buf, 7}; // use the constant string directly! str uri; char *ptr; if (parse_from_header(msg) < 0) { LM_ERR("cannot parse the From header\n"); return notfound; } uri = get_from(msg)->uri; if (uri.len == 0) return notfound; if (strncmp(uri.s, "sip:", 4)==0) { uri.s += 4; uri.len -= 4; } if ((ptr = strfind(uri.s, uri.len, ";", 1))!=NULL) { uri.len = ptr - uri.s; } return uri; }
int tags::Vorbis::readVorbisTagSoup(FILE *fd, char **soup) { *soup = (char*) malloc(1024 * 1024); // ought to be large enough int offset = 0; int cnt = 0; while (true) { char block[512]; if (fread(block, 1, 512, fd) == 0 || cnt > 10) { break; } memcpy(*soup + offset, block, 512); offset += 512; char mark[] = { 5, 'v', 'o', 'r', 'b', 'i', 's' }; int pos = strfind(*soup, mark, offset + 512, 7); if (pos != -1) { return pos; } cnt++; } return 0; }
tags::Vorbis::Vorbis(FILE *fd, QMap<QString, QByteArray> &tags) : myTags(tags) { char *soup; int size = 0; char buf[4]; fread(buf, 1, 4, fd); if (buf[0] == 'f' && buf[1] == 'L' && buf[2] == 'a' && buf[3] == 'C') { // it's FLAC size = readFlacTagSoup(fd, &soup); } else { char header[1024]; char mark[] = { 3, 'v', 'o', 'r', 'b', 'i', 's' }; fseek(fd, 0, SEEK_SET); fread(header, 1, 1024, fd); int pos = strfind(header, mark, 1024, 7); if (pos != -1) { // it's Ogg Vorbis fseek(fd, pos + 7, SEEK_SET); size = readVorbisTagSoup(fd, &soup); } } if (size > 0) parseTagSoup(soup, size); }
/* If string ss appears in string s, return a pointer to the first byte * after ss. Otherwise return NULL. */ const char *strskip(const char *s, const char *ss) { const char *tmp = strfind(s, ss); if (tmp != NULL) { return &tmp[strlen(ss)]; } return NULL; }
jint Java_de_illogical_modo_SpcDecoder_spcLoadRSN(JNIEnv* env, jclass clazz, jstring path) { char cpath[1024]; memset(cpath, 0, 1024); int clen = (*env)->GetStringLength(env, path); (*env)->GetStringUTFRegion(env, path, 0, clen, cpath); rarFileData.ArcName = cpath; rarFileData.OpenMode = RAR_OM_EXTRACT; rarHandle = RAROpenArchive(&rarFileData); if (rarFileData.OpenResult == ERAR_SUCCESS) { int res = RARReadHeader(rarHandle, &rarFileHeader); while(res == ERAR_SUCCESS) { if (strfind(rarFileHeader.FileName, ".spc") != NULL && rsnCount < RSN_ENTRIES && rarFileHeader.UnpSize > 66000 && rarFileHeader.UnpSize < 67000) { rsnEntries[rsnCount] = (char*)malloc(rarFileHeader.UnpSize); if (rsnEntries[rsnCount] != NULL) { rarExtractSpcBytes(0xFFFF, 0, 0, 0); RARSetCallback(rarHandle, rarExtractSpcBytes, (long)rsnEntries[rsnCount]); RARProcessFile(rarHandle, RAR_EXTRACT, NULL, NULL); rsnSize[rsnCount] = rarFileHeader.UnpSize; rsnCount++; } } else if (strfind(rarFileHeader.FileName, ".txt") != NULL && rsnInfo == NULL && rarFileHeader.UnpSize < 10000) { rsnInfo = (char*)calloc(rarFileHeader.UnpSize + 1, 1); if (rsnInfo != NULL) { rarExtractInfoBytes(0xFFFF, 0, 0, 0); RARSetCallback(rarHandle, rarExtractInfoBytes, (long)rsnInfo); RARProcessFile(rarHandle, RAR_EXTRACT, NULL, NULL); } } else { RARProcessFile(rarHandle, RAR_SKIP, NULL, NULL); } res = RARReadHeader(rarHandle, &rarFileHeader); } } RARCloseArchive(rarHandle); return rsnCount; }
void mix_genericerror(void) { if (streq(statusline, "") || strfind(statusline, "...") || strifind(statusline, "generating")) mix_status("Failed!"); else mix_status(NULL); }
int rech_repl(char *ancien,char *nouveau,char *fichier) { FILE *fich; FILE *temp; char temp_nom[64]; char ligne[512]; char result[512]; int debut,debut_r,depl,nolgn,ctrl,nbr_repl=0; int err=0; mk_temp_name(temp_nom,fichier); if((fich=fopen(fichier,"rt"))!=NULL) { if((temp=fopen(temp_nom,"wt"))!=NULL) { while(fgets(ligne,512,fich)!=NULL) { nolgn++; debut=0; debut_r=0; depl=0; while((depl=strfind(ligne+debut,ancien))>=0) { strncpy(result+debut_r,ligne+debut,depl); debut_r+=depl; strcpy(result+debut_r,nouveau); debut_r+=strlen(nouveau); debut+=(depl+strlen(ancien)); nbr_repl++; } strcpy(result+debut_r,ligne+debut); ctrl=fputs(result,temp); if(ctrl==EOF) { err=-3; break; } if(debut!=0) { printf("%4d %s %s",nolgn,ligne,result); } } fclose(temp); } else err=-1; fclose(fich); if(!err) { unlink(fichier); rename(fichier,temp_nom); err=nbr_repl; } } else err=-2; return(err); }
void tags::Vorbis::parseTagSoup(char *soup, int size) { char nullTriple[] = { 0, 0, 0 }; // iterate over entries int offset = 1; // skip the first while (soup[offset] == 0) offset++; qDebug() << QByteArray(soup, size); while (offset < size) { int entrySize = 0; int pos = strfind(soup + offset, nullTriple, size - offset, 3); if (pos != -1) { entrySize = pos - 1; // skip the last } else { entrySize = size - offset; } qDebug() << QByteArray(soup + offset, entrySize); int equalsPos = strfind(soup + offset, "=", entrySize, 1); if (equalsPos != -1) { int keySize = equalsPos; int valueSize = entrySize - keySize - 1; char key[keySize]; char value[valueSize]; memcpy(key, soup + offset, keySize); memcpy(value, soup + offset + keySize + 1, valueSize); myTags[QString(QByteArray(key, keySize)).toUpper()] = QByteArray(value, valueSize); } offset += entrySize + 4; } }
/* get a much bigger step for *. */ static inline int patternStep( const char * s, const char * p) { char temp[8]; int step=0; const char * t=p; while(*t!='*' && *t!='^' && *t!='\0') { step++; t++; } if(!step) //just one character ,such as ^,* return 1; memset(temp,0,sizeof(temp)); strncpy_s(temp,p,abpmin(sizeof(temp)-1,step)); //printf("temp=%s,step=%d\n",temp,step); const char * res=strfind(s,temp); if(!res) //没有找到 return strlen(s); //移动整个字符串 else return abpmax(1,res-s); //找到第一个匹配的字符串的位置 }
/* Find a line in str `block' that starts with `start'. */ static char* findLineStartingWith(str *block, char *start, int ignoreCase) { char *ptr, *bend; str zone; int tlen; bend = block->s + block->len; tlen = strlen(start); ptr = NULL; for (zone = *block; zone.len > 0; zone.len = bend - zone.s) { if (ignoreCase) ptr = strcasefind(zone.s, zone.len, start, tlen); else ptr = strfind(zone.s, zone.len, start, tlen); if (!ptr || ptr==zone.s || ptr[-1]=='\n' || ptr[-1]=='\r') break; zone.s = ptr + tlen; } return ptr; }
/* Returns a function pointer for a function name matching the given string. */ void *debug_get_fn_addr(char *fn_name) { const struct stab *stab_end = __STAB_END__; const struct stab *stabs = __STAB_BEGIN__; const char *stabstr_end = __STABSTR_END__; const char *stabstr = __STABSTR_BEGIN__; static int first_fn_idx = 0; int i = first_fn_idx; int len; const char *stab_fn_name = 0; void *retval = 0; if (!stab_table_valid(stabstr, stabstr_end)) return 0; for (/* i set */; &stabs[i] < stab_end; i++) { if (stabs[i].n_type != N_FUN) continue; first_fn_idx = first_fn_idx ? first_fn_idx : i; /* broken stab, just keep going */ if (!(stabs[i].n_strx < stabstr_end - stabstr)) continue; stab_fn_name = stabstr + stabs[i].n_strx; len = strfind(stab_fn_name, ':') - stab_fn_name; if (!len) continue; /* we have a match. */ if (!strncmp(stab_fn_name, fn_name, len)) { printd("FN name: %s, Addr: %p\n", stab_fn_name, stabs[i].n_value); retval = (void*)stabs[i].n_value; break; } } return retval; }
int exec_load_chrp (inode_t *file, void **dest, void **entry, void **end, uint32_t loffset) { #define TMPNAME_LEN 512 unsigned char tmpname[TMPNAME_LEN], *tmpp, *buf, *pos, *endc, c; XML_tag_t *tag, *tmp, *first; part_t *part; inode_t *inode; int state; int script_type = CHRP_SCRIPT_IGNORE; uint32_t crc, offset = 0; int ret, rel = 0; buf = malloc(16384); /* Check the file head */ file_seek(file, loffset); fs_read(file, buf, 11); if (memcmp(buf, "<CHRP-BOOT>", 11) != 0) { ERROR("Not an Apple CHRP boot file !\n"); return -2; } /* Re-seek at start of the file and start parsing it */ file_seek(file, loffset); pos = buf; tag = NULL; first = NULL; ret = -1; fs_read(file, &c, 1); offset++; for (state = XML_STATE_TAG; state != XML_STATE_OUT;) { /* Get next char */ fs_read(file, &c, 1); offset++; if ((state == XML_STATE_TAG && c != '>') || (state == XML_STATE_DATA && c != '<')) { *pos++ = c; continue; } *pos++ = '\0'; switch (state) { case XML_STATE_TAG: if (*buf == '/') { if (tag == NULL || strcmp(buf + 1, tag->name) != 0) { ERROR("XML error: open name: '%s' close name: '%s'\n", buf + 1, tag->name); goto out; } DPRINTF("Close tag: '%s'\n", tag->name); switch (XML_get_type(tag->name)) { case CHRP_TAG_CHRP_BOOT: /* Nothing to do */ break; case CHRP_TAG_COMPATIBLE: /* Won't check... */ pos = tag->data; if (*(char *)tag->data == 0x0d) { pos++; } DPRINTF("Compatible: '%s'\n", pos); break; case CHRP_TAG_DESCRIPTION: pos = tag->data; if (*(char *)tag->data == 0x0d) { pos++; } DPRINTF("Description: '%s'\n", pos); break; case CHRP_TAG_BOOT_SCRIPT: /* Here is the interresting part... */ crc = crc32(0, tag->data, tag->dlen); #if 0 DPRINTF("Forth script: %08x\n%s\n", crc, (char *)tag->data); #endif switch (crc) { case 0x5464F92C: /* Mandrake 9.1 CD1 boot script */ case 0x4BC74ECF: /* Mandrake 10.1 & 10.2 CD1 boot script */ case 0x5B265246: /* Gentoo 1.2-r1 */ /* Gentoo 2004.1 minimal install CD */ /* Gentoo 1.4 live CDROM */ /* Knopix PPC beta-pre12 */ case 0x75420D8A: /* Debian woody */ /* Debian 3.0r1 */ script_type = CHRP_SCRIPT_LOAD_BOOT; goto do_script; case 0x633e4c9c: /* Debian Sarge */ case 0xbe3abf60: /* Debian Sarge, installed on a hard disk drive */ script_type = CHRP_SCRIPT_LOAD_BOOT; goto do_script; case 0x07b86bfe: /* Linux Fedora Core 3 */ script_type = CHRP_SCRIPT_LOAD_BOOT; goto do_script; case 0x9ccdf371: script_type = CHRP_SCRIPT_LOAD_BOOT; goto do_script; case 0xEF423926: /* OpenBSD 3.4 */ case 0x68e4f265: /* OpenBSD 3.5 */ case 0x3b7ea9e1: /* OpenBSD 3.6 */ script_type = CHRP_SCRIPT_LOAD_BOOT; goto do_script; case 0xB7981DBC: /* iBook 2 hw test CDROM */ #if 1 script_type = CHRP_SCRIPT_LOAD_BOOT; goto do_script; #endif case 0xEA06C1A7: /* MacOS 9.2 boot script: * the XCOFF loader is embedded in the file... */ case 0x53A95958: /* iBook 2 restore CD (MacOS X 10.2) */ script_type = CHRP_SCRIPT_EMBEDDED; pos = strfind(tag->data, "elf-offset"); if (pos != NULL) { /* Go backward until we get the value */ for (--pos; *pos < '0' || *pos > '9'; pos--) continue; for (; *pos >= '0' && *pos <= '9'; pos--) continue; offset = strtol(pos, NULL, 16); goto do_script; } ERROR("Didn't find boot file offset\n"); goto out; case 0x8d5acb86: /* Darwin-7.01 * The executable file is embedded after the script */ script_type = CHRP_SCRIPT_EMBEDDED; DPRINTF("Boot file embedded at the end of boot script\n"); break; default: ERROR("XML error: unknown Forth script: %08x\n%s\n", crc, (char *)tag->data); goto out; } break; do_script: switch (script_type) { case CHRP_SCRIPT_LOAD_BOOT: pos = strfind(tag->data, "boot"); if (pos != NULL) { /* Eat everything until file name */ for (pos += 4; *pos != ','; pos++) continue; /* Eat ',' */ for (++pos; isspace(*pos) || *pos == '"'; pos++) continue; /* Find file name end */ redo: for (endc = pos; *endc != ' ' && *endc != '"' && *endc != '\n' && *endc != '\r'; endc++) { if (*endc == '\\') *endc = '/'; } if (memcmp(pos, "ofwboot", 7) == 0) { for (pos = endc + 1; *pos == ' '; pos++) continue; goto redo; } *endc = '\0'; } DPRINTF("Real boot file is: '%s'\n", pos); part = fs_inode_get_part(file); /* check if it's a path or just a file */ tmpp = pos; if ((pos[0] == '/' && pos[1] == '/') || pos[0] != '/') { unsigned char *bootdir; bootdir = fs_get_boot_dirname(part_fs(part)); if (bootdir == NULL) { ERROR("Cannot get boot directory name\n"); bug(); } snprintf(tmpname, TMPNAME_LEN, "%s/%s", bootdir, pos); tmpname[TMPNAME_LEN - 1] = '\0'; rel++; pos = tmpname; DPRINTF("'%s' => '%s'\n", bootdir, pos); } retry: inode = fs_open(part_fs(part), pos); if (inode == NULL) { ERROR("Real boot inode '%s' not found\n", pos); /* Try in root directory */ if (rel == 1) { for (; *tmpp == '/'; tmpp++) continue; snprintf(tmpname, TMPNAME_LEN, "/%s", tmpp); tmpname[TMPNAME_LEN - 1] = '\0'; rel++; goto retry; } bug(); } ret = _bootfile_load(inode, dest, entry, end, 0, -1); fs_close(inode); goto out; case CHRP_SCRIPT_EMBEDDED: DPRINTF("Exec offset: %d %08x\n", offset, offset); ret = 0; goto out; case CHRP_SCRIPT_IGNORE: break; } break; case CHRP_TAG_OS_BADGE_ICONS: case CHRP_TAG_ICON: /* Ignore it */ break; case CHRP_TAG_BITMAP: /* Ignore it */ break; case CHRP_TAG_LICENSE: /* Ignore it */ pos = tag->data; if (*(char *)tag->data == 0x0d) { pos++; } DPRINTF("License: '%s'\n", pos); break; default: ERROR("XML error: unknown tag: '%s'\n", tag->name); goto out; } tmp = tag->up; if (tmp == NULL) state = XML_STATE_OUT; else state = XML_STATE_DATA; free(tag->name); free(tag->data); free(tag); tag = tmp; } else { tmp = malloc(sizeof(XML_tag_t)); if (tmp == NULL) { ERROR("Cannot allocate new tag\n"); goto out; } tmp->up = tag; /* Ignore tag attributes */ pos = strchr(buf, ' '); if (pos != NULL) *pos = '\0'; tmp->name = strdup(buf); tag = tmp; if (first == NULL) first = tag; DPRINTF("Open tag '%s'\n", tag->name); state = XML_STATE_DATA; } break; case XML_STATE_DATA: if (tag->data == NULL) { tag->dlen = pos - buf; tag->data = malloc(tag->dlen); memcpy(tag->data, buf, tag->dlen); } state = XML_STATE_TAG; break; } pos = buf; } ret = 0; fs_read(file, &c, 1); fs_read(file, &c, 1); offset += 2; out: #if 1 for (; tag != NULL; tag = tmp) { tmp = tag->up; free(tag->name); free(tag->data); free(tag); } #endif if (ret == 0 && script_type == CHRP_SCRIPT_EMBEDDED) { DPRINTF("Load embedded file from offset %d (%d => %d)\n", offset, loffset, loffset + offset); ret = _bootfile_load(file, dest, entry, end, loffset + offset, -1); } DPRINTF("Done\n"); return ret; }
int main () { char bob [] = "jelly"; printf("%c", *strfind(bob, 'l')); return 0; }
static bool _check_extension(const char* name) { static const char* exts = NULL; if(exts == NULL) exts = (char*)glGetString(GL_EXTENSIONS); return strfind(name, exts) != -1; }
int main() { printf("%s\n",strfind("aasdf", "s") ); printf("%s\n",strfind("aasdf", "as") ); printf("%s\n",strfind("aasdf", "f") ); }
uint32_t calc(int argc, char* argv[]) { calcErrFlag = 0; int now = 0; for(int i = 1; i < argc; ++i) for(int j = 0; argv[i][j]; ++j) buf[now++] = argv[i][j]; buf[now] = 0; cprintf("%s : ", buf); now = 0; for(int i = 0; buf[i]; ++i) { int flag = 0; for(int j = 0; j < NOPERATORS; ++j) { if(buf[i] == operator[j].symbol[0]) { flag = 1; calcBuf[now++] = buf[i]; if(buf[i + 1] == '<' || buf[i + 1] == '>' ) break; calcBuf[now++] = ' '; break; } } if(flag) continue; if('0' <= buf[i] && buf[i] <= '9') { while( buf[i] == 'x' || '0' <= buf[i] && buf[i] <= '9' || 'a' <= buf[i] && buf[i] <= 'f' || 'A' <= buf[i] && buf[i] <= 'F' ) { calcBuf[now++] = buf[i++]; } calcBuf[now++] = ' '; i --; continue; } flag = *strfind(reservedChars, buf[i]); if(flag) { cprintf("Invalid character: %c\n", buf[i]); calcErrFlag = -1; return -1; } while(1) { flag = *strfind(reservedChars, buf[i]); if(!flag && buf[i]) calcBuf[now++] = buf[i++]; else { calcBuf[now++] = ' ', i--; break; } } } calcBuf[now] = 0; // cprintf("%s\n", calcBuf); char** calcComp = split(calcBuf); stackn = 0; valuen = 0; int m = 0; for(int i = 0; calcComp[i]; ++i) { m = i; int j; if((j = findOpt(calcComp[i])) != -1) { if(operator[j].type == OPT_LBRACE || operator[j].type == OPT_RBRACE) calcMark[i] = operator[j].type; else if(i == 0 || calcMark[i-1] == OPT_UNO || calcMark[i-1] == OPT_BINARY || calcMark[i-1] == OPT_LBRACE) calcMark[i] = OPT_UNO; else calcMark[i] = OPT_BINARY; continue; } if('0' <= calcComp[i][0] && calcComp[i][0] <= '9') { calcMark[i] = OPT_VALUE; continue; } calcMark[i] = OPT_SYMBOL; } /* for(int i = 0; i <= m; ++i) cprintf("%d ", calcMark[i]); cprintf("\n"); */ for(int i = m; i >= 0; --i) { //printCalcStack(); int j; struct DebugInfo* p; switch(calcMark[i]) { case OPT_UNO: j = findSpecOpt(calcComp[i], OPT_UNO); if(j == -1) { cprintf("Invalid expression!\n"); calcErrFlag = -1; return -1; } calcStack[++stackn] = operator[j]; doCalc(); break; case OPT_BINARY: j = findSpecOpt(calcComp[i], OPT_BINARY); if(j == -1) { cprintf("Invalid expression!\n"); calcErrFlag = -1; return -1; } while( stackn > 0 && calcStack[stackn].type == OPT_BINARY && calcStack[stackn].priority > operator[j].priority) doCalc(); calcStack[++stackn] = operator[j]; break; case OPT_LBRACE: while(calcStack[stackn].type != OPT_RBRACE) doCalc(); stackn--; break; case OPT_RBRACE: calcStack[++stackn].type = OPT_RBRACE; break; case OPT_VALUE: calcValue[++valuen] = strToInt(calcComp[i]); break; case OPT_SYMBOL: p = findSymbol(pinfo.pc, calcComp[i]); if(p == 0) { cprintf("Cannot find symbol: %s\n", calcComp[i]); calcErrFlag = -1; return -1; } uint32_t vaddr = p->vaddr; int type = 0; if(p->type != N_GSYM) type = 1; subArgv[0] = vaddr; subArgv[1] = buf; subArgv[2] = type; subArgv[3] = 0; int result = doSysDebug(DEBUG_PRINT, subArgv); if(result < 0) { cprintf("%s", subArgv[1]); calcErrFlag = -1; return -1; } calcValue[++valuen] = strToInt(subArgv[1]); break; } } while(stackn) { //printCalcStack(); doCalc(); } cprintf("%d\n", calcValue[1]); return calcValue[1]; }
// Search and Replace ZString IString_ReplaceIString ( IStringPtr self, IStringPtr what, IStringPtr with, int IgnoreCase ) { ZString from, to, find; u32 count, oldsize, newsize; // Sanity checks. Cannot replace an empty string ESIF_ASSERT(self && what && with); if (self->data_len <= 1 || what->data_len <= 1) { return 0; } // Count occurances of replacment string in original string for (count = 0, find = (ZString)self->buf_ptr; (find = (ZString)strfind(find, (ZString)what->buf_ptr, IgnoreCase)) != NULL; count++) find += what->data_len - 1; // Compute new string size and Resize if necessary oldsize = self->data_len; newsize = self->data_len + (count * (int)(esif_ccb_max(with->data_len, 1) - what->data_len)); if (newsize > self->buf_len) { #ifdef ISTRING_AUTOGROW if (IString_Resize(self, newsize + ISTRING_AUTOGROW) == NULL) #endif return 0; } // Do an in-string replacement so that another copy of the string does not need to be allocated // a) newsize <= oldsize: Do a left-to-right copy replacment // b) newsize > oldsize: Move string to end of newsize buffer, then do a left-to-right copy replacement from = to = (ZString)self->buf_ptr; self->data_len = newsize; if (newsize > oldsize) { // Move string to end of reallocated (data_len) buffer esif_ccb_memmove(((ZString)self->buf_ptr) + (newsize - oldsize), (ZString)self->buf_ptr, oldsize); from += newsize - oldsize; } // Do a left-to-right copy (from -> to), replacing each occurance of old string (what) with new string (with) while ((find = (ZString)strfind(from, (ZString)what->buf_ptr, IgnoreCase)) != NULL) { if (from > to) { esif_ccb_memcpy(to, from, (size_t)(find - from)); } to += (size_t)(find - from); if (with->data_len > 0) { esif_ccb_memcpy(to, (ZString)with->buf_ptr, with->data_len - 1); to += with->data_len - 1; } from = find + (what->data_len > 0 ? what->data_len - 1 : 0); } // Copy remainder of string, if any if (to < from) { esif_ccb_memcpy(to, from, newsize - (size_t)(to - (ZString)self->buf_ptr)); } to += newsize - (size_t)(to - (ZString)self->buf_ptr); // zero out remainder of old string, if any if (oldsize > newsize) { esif_ccb_memset(to, 0, oldsize - newsize); } return (ZString)self->buf_ptr; }
static struct http_request * uh_http_header_recv(struct client *cl) { static char buffer[UH_LIMIT_MSGHEAD]; char *bufptr = &buffer[0]; char *idxptr = NULL; struct timeval timeout; fd_set reader; ssize_t blen = sizeof(buffer)-1; ssize_t rlen = 0; memset(buffer, 0, sizeof(buffer)); while( blen > 0 ) { FD_ZERO(&reader); FD_SET(cl->socket, &reader); /* fail after 0.1s */ timeout.tv_sec = 0; timeout.tv_usec = 100000; /* check whether fd is readable */ if( select(cl->socket + 1, &reader, NULL, NULL, &timeout) > 0 ) { /* receive data */ ensure_out(rlen = uh_tcp_peek(cl, bufptr, blen)); if( (idxptr = strfind(buffer, sizeof(buffer), "\r\n\r\n", 4)) ) { ensure_out(rlen = uh_tcp_recv(cl, bufptr, (int)(idxptr - bufptr) + 4)); /* header read complete ... */ blen -= rlen; return uh_http_header_parse(cl, buffer, sizeof(buffer) - blen - 1); } else { ensure_out(rlen = uh_tcp_recv(cl, bufptr, rlen)); /* unexpected eof - #7904 */ if( rlen == 0 ) return NULL; blen -= rlen; bufptr += rlen; } } else { /* invalid request (unexpected eof/timeout) */ return NULL; } } /* request entity too large */ uh_http_response(cl, 413, "Request Entity Too Large"); out: return NULL; }
// debuginfo_eip(addr, info) // // Fill in the 'info' structure with information about the specified // instruction address, 'addr'. Returns 0 if information was found, and // negative if not. But even if it returns negative it has stored some // information into '*info'. // int debuginfo_eip(uintptr_t addr, struct Eipdebuginfo *info) { const struct Stab *stabs, *stab_end; const char *stabstr, *stabstr_end; int lfile, rfile, lfun, rfun, lline, rline; // Initialize *info info->eip_file = "<unknown>"; info->eip_line = 0; info->eip_fn_name = "<unknown>"; info->eip_fn_namelen = 9; info->eip_fn_addr = addr; info->eip_fn_narg = 0; // Find the relevant set of stabs if (addr >= ULIM) { stabs = __STAB_BEGIN__; stab_end = __STAB_END__; stabstr = __STABSTR_BEGIN__; stabstr_end = __STABSTR_END__; } else { // The user-application linker script, user/user.ld, // puts information about the application's stabs (equivalent // to __STAB_BEGIN__, __STAB_END__, __STABSTR_BEGIN__, and // __STABSTR_END__) in a structure located at virtual address // USTABDATA. const struct UserStabData *usd = (const struct UserStabData *) USTABDATA; // Make sure this memory is valid. // Return -1 if it is not. Hint: Call user_mem_check. // LAB 3: Your code here. if(user_mem_check(curenv, usd, sizeof(struct UserStabData), PTE_U) < 0) { return -1; } stabs = usd->stabs; stab_end = usd->stab_end; stabstr = usd->stabstr; stabstr_end = usd->stabstr_end; // Make sure the STABS and string table memory is valid. // LAB 3: Your code here. if(user_mem_check(curenv, stabs, stab_end-stabs, PTE_U) < 0) { return -1; } if(user_mem_check(curenv, stabstr, stabstr_end-stabstr, PTE_U) < 0) { return -1; } } // String table validity checks if (stabstr_end <= stabstr || stabstr_end[-1] != 0) return -1; // Now we find the right stabs that define the function containing // 'eip'. First, we find the basic source file containing 'eip'. // Then, we look in that source file for the function. Then we look // for the line number. // Search the entire set of stabs for the source file (type N_SO). lfile = 0; rfile = (stab_end - stabs) - 1; stab_binsearch(stabs, &lfile, &rfile, N_SO, addr); if (lfile == 0) return -1; // Search within that file's stabs for the function definition // (N_FUN). lfun = lfile; rfun = rfile; stab_binsearch(stabs, &lfun, &rfun, N_FUN, addr); if (lfun <= rfun) { // stabs[lfun] points to the function name // in the string table, but check bounds just in case. if (stabs[lfun].n_strx < stabstr_end - stabstr) info->eip_fn_name = stabstr + stabs[lfun].n_strx; info->eip_fn_addr = stabs[lfun].n_value; addr -= info->eip_fn_addr; // Search within the function definition for the line number. lline = lfun; rline = rfun; } else { // Couldn't find function stab! Maybe we're in an assembly // file. Search the whole file for the line number. info->eip_fn_addr = addr; lline = lfile; rline = rfile; } // Ignore stuff after the colon. info->eip_fn_namelen = strfind(info->eip_fn_name, ':') - info->eip_fn_name; // Search within [lline, rline] for the line number stab. // If found, set info->eip_line to the right line number. // If not found, return -1. // // Hint: // There's a particular stabs type used for line numbers. // Look at the STABS documentation and <inc/stab.h> to find // which one. // Your code here. stab_binsearch(stabs, &lline, &rline, N_SLINE, addr); if (lline <= rline) { info->eip_line = stabs[lline].n_desc; } else { return -1; } // Search backwards from the line number for the relevant filename // stab. // We can't just use the "lfile" stab because inlined functions // can interpolate code from a different file! // Such included source files use the N_SOL stab type. while (lline >= lfile && stabs[lline].n_type != N_SOL && (stabs[lline].n_type != N_SO || !stabs[lline].n_value)) lline--; if (lline >= lfile && stabs[lline].n_strx < stabstr_end - stabstr) info->eip_file = stabstr + stabs[lline].n_strx; // Set eip_fn_narg to the number of arguments taken by the function, // or 0 if there was no containing function. if (lfun < rfun) for (lline = lfun + 1; lline < rfun && stabs[lline].n_type == N_PSYM; lline++) info->eip_fn_narg++; return 0; }
// debuginfo_eip(addr, info) // // Fill in the 'info' structure with information about the specified // instruction address, 'addr'. Returns 0 if information was found, and // negative if not. But even if it returns negative it has stored some // information into '*info'. // int debuginfo_eip(uintptr_t addr, struct Eipdebuginfo *info) { const struct Stab *stabs, *stab_end; const char *stabstr, *stabstr_end; int lfile, rfile, lfun, rfun, lline, rline; // Initialize *info info->eip_file = "<unknown>"; info->eip_line = 0; info->eip_fn_name = "<unknown>"; info->eip_fn_namelen = 9; info->eip_fn_addr = addr; info->eip_fn_narg = 0; // Find the relevant set of stabs if (addr >= ULIM) { stabs = __STAB_BEGIN__; stab_end = __STAB_END__; stabstr = __STABSTR_BEGIN__; stabstr_end = __STABSTR_END__; } else { // Can't search for user-level addresses yet! panic("User address"); } // String table validity checks if (stabstr_end <= stabstr || stabstr_end[-1] != 0) return -1; // Now we find the right stabs that define the function containing // 'eip'. First, we find the basic source file containing 'eip'. // Then, we look in that source file for the function. Then we look // for the line number. // Search the entire set of stabs for the source file (type N_SO). lfile = 0; rfile = (stab_end - stabs) - 1; stab_binsearch(stabs, &lfile, &rfile, N_SO, addr); if (lfile == 0) return -1; // Search within that file's stabs for the function definition // (N_FUN). lfun = lfile; rfun = rfile; stab_binsearch(stabs, &lfun, &rfun, N_FUN, addr); if (lfun <= rfun) { // stabs[lfun] points to the function name // in the string table, but check bounds just in case. if (stabs[lfun].n_strx < stabstr_end - stabstr) info->eip_fn_name = stabstr + stabs[lfun].n_strx; info->eip_fn_addr = stabs[lfun].n_value; addr -= info->eip_fn_addr; // Search within the function definition for the line number. lline = lfun; rline = rfun; } else { // Couldn't find function stab! Maybe we're in an assembly // file. Search the whole file for the line number. info->eip_fn_addr = addr; lline = lfile; rline = rfile; } // Ignore stuff after the colon. info->eip_fn_namelen = strfind(info->eip_fn_name, ':') - info->eip_fn_name; // Search within [lline, rline] for the line number stab. // If found, set info->eip_line to the right line number. // If not found, return -1. // // Hint: // There's a particular stabs type used for line numbers. // Look at the STABS documentation and <inc/stab.h> to find // which one. // Your code here. stab_binsearch(stabs, &lline, &rline, N_SLINE, addr); info.eip_line = (lline <= rline)? stabs[rrline].n_desc: -1; // Search backwards from the line number for the relevant filename // stab. // We can't just use the "lfile" stab because inlined functions // can interpolate code from a different file! // Such included source files use the N_SOL stab type. while (lline >= lfile && stabs[lline].n_type != N_SOL && (stabs[lline].n_type != N_SO || !stabs[lline].n_value)) lline--; if (lline >= lfile && stabs[lline].n_strx < stabstr_end - stabstr) info->eip_file = stabstr + stabs[lline].n_strx; // Set eip_fn_narg to the number of arguments taken by the function, // or 0 if there was no containing function. if (lfun < rfun) for (lline = lfun + 1; lline < rfun && stabs[lline].n_type == N_PSYM; lline++) info->eip_fn_narg++; return 0; }
int t1_rlist(REMAILER remailer[], int badchains[MAXREM][MAXREM]) { FILE *list, *excl; int i, listed = 0; int n = 0; char line[2 * LINELEN], l2[LINELEN], name[LINELEN], *flags; BUFFER *starex; starex = buf_new(); excl = mix_openfile(STAREX, "r"); if (excl != NULL) { buf_read(starex, excl); fclose(excl); } list = mix_openfile(TYPE1LIST, "r"); if (list == NULL) { buf_free(starex); return (-1); } while (fgets(line, sizeof(line), list) != NULL && n < MAXREM) { if (strleft(line, "$remailer") && strchr(line, '<') && strchr(line, '>') && strchr(line, '{') && strchr(line, '{') + 4 < strchr(line, '}')) { if (line[strlen(line) - 1] == '\n') line[strlen(line) - 1] = '\0'; if (line[strlen(line) - 1] == '\r') line[strlen(line) - 1] = '\0'; while (line[strlen(line) - 1] == ' ') line[strlen(line) - 1] = '\0'; if (line[strlen(line) - 1] != ';' && fgets(l2, sizeof(l2), list) != NULL) strcatn(line, l2, LINELEN); flags = strchr(line, '>'); strncpy(name, strchr(line, '{') + 2, strchr(line, '}') - strchr(line, '{') - 3); name[strchr(line, '}') - strchr(line, '{') - 3] = '\0'; name[20] = '\0'; for (i = 1; i <= n; i++) if (streq(name, remailer[i].name)) break; if (i > n) { /* not in mix list */ n++; strcpy(remailer[i].name, name); strncpy(remailer[i].addr, strchr(line, '<') + 1, strchr(line, '>') - strchr(line, '<')); remailer[i].addr[strchr(line, '>') - strchr(line, '<') - 1] = '\0'; remailer[i].flags.mix = 0; remailer[i].flags.post = strifind(flags, " post"); } remailer[i].flags.cpunk = strfind(flags, " cpunk"); remailer[i].flags.pgp = strfind(flags, " pgp"); remailer[i].flags.pgponly = strfind(flags, " pgponly"); remailer[i].flags.latent = strfind(flags, " latent"); remailer[i].flags.middle = strfind(flags, " middle"); remailer[i].flags.ek = strfind(flags, " ek"); remailer[i].flags.esub = strfind(flags, " esub"); remailer[i].flags.hsub = strfind(flags, " hsub"); remailer[i].flags.newnym = strfind(flags, " newnym"); remailer[i].flags.nym = strfind(flags, " nym"); remailer[i].info[1].reliability = 0; remailer[i].info[1].latency = 0; remailer[i].info[1].history[0] = '\0'; remailer[i].flags.star_ex = bufifind(starex, name); } if (strleft(line, "-----------------------------------------------------------------------")) break; } n++; /* ?? */ while (fgets(line, sizeof(line), list) != NULL) { if (strlen(line) >= 72 && strlen(line) <= 73) for (i = 1; i < n; i++) if (strleft(line, remailer[i].name) && line[strlen(remailer[i].name)] == ' ') { strncpy(remailer[i].info[1].history, line + 42, 12); remailer[i].info[1].history[12] = '\0'; remailer[i].info[1].reliability = 10000 * N(line[64]) + 1000 * N(line[65]) + 100 * N(line[66]) + 10 * N(line[68]) + N(line[69]); remailer[i].info[1].latency = 36000 * N(line[55]) + 3600 * N(line[56]) + 600 * N(line[58]) + 60 * N(line[59]) + 10 * N(line[61]) + N(line[62]); listed++; } } fclose(list); parse_badchains(badchains, TYPE1LIST, "Broken type-I remailer chains", remailer, n); if (listed < 4) /* we have no valid reliability info */ for (i = 1; i < n; i++) remailer[i].info[1].reliability = 10000; #ifdef USE_PGP pgp_rlist(remailer, n); #endif /* USE_PGP */ buf_free(starex); return (n); }
bool CHttpClient::ParseHeaders(const char * szBuffer, int& iBufferSize, int& iHeaderSize) { // Find amount of whitespace int iWhiteSpace = 0; for (int i = 0; i < iBufferSize; i++) { if (szBuffer[i] != ' ') break; // Increment the whitespace amount iWhiteSpace++; } // Increment the header size iHeaderSize += iWhiteSpace; // Ignore the version, status code and status message // Will be in format 'HTTP/1.0 200 OK\r\n' int iIgnore = strfind(szBuffer, iBufferSize, "\r\n", iHeaderSize); if (iIgnore == -1) return false; int iIgnoreSize = (iIgnore - iHeaderSize); // Increment the header size iHeaderSize += (iIgnoreSize + 2); // + 2 for '\r\n' // Find all headers int iNameSplit; int iValueSplit; while ((iNameSplit = strfind(szBuffer, iBufferSize, ": ", iHeaderSize, "\r\n")) != -1) { // Get the header name int iNameSize = (iNameSplit - iHeaderSize); CString strName; strName.Set((szBuffer + iHeaderSize), iNameSize); // Increment the header size iHeaderSize += (iNameSize + 2); // + 2 for '\r\n' // Find the value end iValueSplit = strfind(szBuffer, iBufferSize, "\r\n", iHeaderSize); // Did we not find a value end? if (iValueSplit == -1) return false; // Get the header value int iValueSize = (iValueSplit - iHeaderSize); CString strValue; strValue.Set((szBuffer + iHeaderSize), iValueSize); // Increment the header size iHeaderSize += (iValueSize + 2); // + 2 for '\r\n' // Add the header to the header map m_headerMap[strName] = strValue; } // Did we not get any headers? if (m_headerMap.empty()) return false; // Ignore the '\r\n' after the headers iHeaderSize += 2; // Decrement the buffer size by the header size iBufferSize -= iHeaderSize; // Success return true; }
static struct http_request * uh_http_header_parse(struct client *cl, char *buffer, int buflen) { char *method = &buffer[0]; char *path = NULL; char *version = NULL; char *headers = NULL; char *hdrname = NULL; char *hdrdata = NULL; int i; int hdrcount = 0; static struct http_request req; memset(&req, 0, sizeof(req)); /* terminate initial header line */ if( (headers = strfind(buffer, buflen, "\r\n", 2)) != NULL ) { buffer[buflen-1] = 0; *headers++ = 0; *headers++ = 0; /* find request path */ if( (path = strchr(buffer, ' ')) != NULL ) *path++ = 0; /* find http version */ if( (path != NULL) && ((version = strchr(path, ' ')) != NULL) ) *version++ = 0; /* check method */ if( strcmp(method, "GET") && strcmp(method, "HEAD") && strcmp(method, "POST") ) { /* invalid method */ uh_http_response(cl, 405, "Method Not Allowed"); return NULL; } else { switch(method[0]) { case 'G': req.method = UH_HTTP_MSG_GET; break; case 'H': req.method = UH_HTTP_MSG_HEAD; break; case 'P': req.method = UH_HTTP_MSG_POST; break; } } /* check path */ if( !path || !strlen(path) ) { /* malformed request */ uh_http_response(cl, 400, "Bad Request"); return NULL; } else { req.url = path; } /* check version */ if( (version == NULL) || (strcmp(version, "HTTP/0.9") && strcmp(version, "HTTP/1.0") && strcmp(version, "HTTP/1.1")) ) { /* unsupported version */ uh_http_response(cl, 400, "Bad Request"); return NULL; } else { req.version = strtof(&version[5], NULL); } /* process header fields */ for( i = (int)(headers - buffer); i < buflen; i++ ) { /* found eol and have name + value, push out header tuple */ if( hdrname && hdrdata && (buffer[i] == '\r' || buffer[i] == '\n') ) { buffer[i] = 0; /* store */ if( (hdrcount + 1) < array_size(req.headers) ) { req.headers[hdrcount++] = hdrname; req.headers[hdrcount++] = hdrdata; hdrname = hdrdata = NULL; } /* too large */ else { uh_http_response(cl, 413, "Request Entity Too Large"); return NULL; } } /* have name but no value and found a colon, start of value */ else if( hdrname && !hdrdata && ((i+1) < buflen) && (buffer[i] == ':') ) { buffer[i] = 0; hdrdata = &buffer[i+1]; while ((hdrdata + 1) < (buffer + buflen) && *hdrdata == ' ') hdrdata++; } /* have no name and found [A-Za-z], start of name */ else if( !hdrname && isalpha(buffer[i]) ) { hdrname = &buffer[i]; } } /* valid enough */ req.redirect_status = 200; return &req; } /* Malformed request */ uh_http_response(cl, 400, "Bad Request"); return NULL; }