TEST(wchar, wcsstr_wcswcs) { const wchar_t* haystack = L"matches hello world, not the second hello world"; const wchar_t* empty_needle = L""; const wchar_t* good_needle = L"ll"; const wchar_t* bad_needle = L"wort"; ASSERT_EQ(haystack, wcsstr(haystack, empty_needle)); ASSERT_EQ(&haystack[10], wcsstr(haystack, good_needle)); ASSERT_EQ(NULL, wcsstr(haystack, bad_needle)); ASSERT_EQ(haystack, wcswcs(haystack, empty_needle)); ASSERT_EQ(&haystack[10], wcswcs(haystack, good_needle)); ASSERT_EQ(NULL, wcswcs(haystack, bad_needle)); }
wchar_t* UnescapeQuotes(wchar_t* data) { while(wchar_t* quotePos = wcswcs(data, L"\\\"")) for (++quotePos;quotePos < data + wcslen(data); ++quotePos) (*(quotePos - 1)) = *quotePos; return data; }
StringList *split(wchar *str,wchar *delimiter) { int len_delimiter=wcslen(delimiter); StringList *ret=new StringList(); wchar *p,*q; p=str; while(1){ q=wcswcs(p,delimiter); if(q!=NULL){ ret->put(-1,p,0,q-p); p=q+len_delimiter; }else{ ret->put(-1,p); break; } } return ret; }
static TACommandVerdict wcswcs_cmd(TAThread thread,TAInputStream stream) { wchar_t* ws1; wchar_t* ws2; wchar_t* res; // Prepare ws1 = (wchar_t*)readPointer(&stream); ws2 = (wchar_t*)readPointer(&stream); START_TARGET_OPERATION(thread); // Execute res = wcswcs(ws1, ws2); END_TARGET_OPERATION(thread); // Response writePointer(thread, res); sendResponse(thread); return taDefaultVerdict; }
/* * Do grep on a single file. * Return true in any lines matched. * * We have two strategies: * The fast one is used when we have a single pattern with * a string known to occur in the pattern. We can then * do a BMG match on the whole buffer. * This is an order of magnitude faster. * Otherwise we split the buffer into lines, * and check for a match on each line. */ static int grep(int fd, const char *fn) { PATTERN *pp; off_t data_len; /* length of the data chunk */ off_t line_len; /* length of the current line */ off_t line_offset; /* current line's offset from the beginning */ off_t blkoffset; /* line_offset but context-compatible */ long long lineno, linenum; long long matches = 0; /* Number of matching lines */ long long conacnt = 0, conbcnt = 0; /* context line count */ int newlinep; /* 0 if the last line of file has no newline */ char *ptr, *ptrend, *prntptr, *prntptrend; char *nextptr = NULL, *nextend = NULL; char *conptr = NULL, *conptrend = NULL; char *matchptr = NULL; int conaprnt = 0, conbprnt = 0, lastmatch = 0; int nearmatch = conmatches ? 1 : 0; /* w/in N+1 of last match */ size_t prntlen; if (patterns == NULL) return (0); /* no patterns to match -- just return */ pp = patterns; if (use_bmg) { bmgcomp(pp->pattern, strlen(pp->pattern)); } if (use_wchar && outline == NULL) { outbuflen = BUFSIZE + 1; outline = malloc(sizeof (wchar_t) * outbuflen); if (outline == NULL) { (void) fprintf(stderr, gettext("%s: out of memory\n"), cmdname); exit(2); } } if (prntbuf == NULL) { prntbuflen = BUFSIZE; if ((prntbuf = malloc(prntbuflen + 1)) == NULL) { (void) fprintf(stderr, gettext("%s: out of memory\n"), cmdname); exit(2); } } if (conflag && (conbuf == NULL)) { conbuflen = BUFSIZE; if ((conbuf = malloc(BUFSIZE+1)) == NULL) { (void) fprintf(stderr, gettext("%s: out of memory\n"), cmdname); exit(2); } } blkoffset = line_offset = 0; lineno = 0; linenum = 1; newlinep = 1; data_len = 0; for (; ; ) { long count; off_t offset = 0; int eof = 0, rv = REG_NOMATCH; char separate; if (data_len == 0) { /* * If no data in the buffer, reset ptr */ ptr = prntbuf; if (conptr == NULL) conptrend = conptr = conbuf; } if (ptr == prntbuf) { /* * The current data chunk starts from prntbuf. * This means either the buffer has no data * or the buffer has no newline. * So, read more data from input. */ count = read(fd, ptr + data_len, prntbuflen - data_len); if (count < 0) { /* read error */ if (cflag) { if (outfn && !rflag) { (void) fprintf(stdout, "%s:", fn); } if (!qflag && !rflag) { (void) fprintf(stdout, "%lld\n", matches); } } return (0); } else if (count == 0) { /* no new data */ eof = 1; /* we never want to match EOF */ pp = (PATTERN *) !nvflag; if (data_len == 0) { /* end of file already reached */ if (conflag) { *conptrend = '\n'; goto L_next_line; } else { goto out; } } /* last line of file has no newline */ ptrend = ptr + data_len; newlinep = 0; goto L_start_process; } offset = data_len; data_len += count; } /* * Look for newline in the chunk * between ptr + offset and ptr + data_len - offset. */ ptrend = find_nl(ptr + offset, data_len - offset); if (ptrend == NULL) { /* no newline found in this chunk */ if (ptr > prntbuf) { /* * Move remaining data to the beginning * of the buffer. * Remaining data lie from ptr for * data_len bytes. */ (void) memmove(prntbuf, ptr, data_len); } if (data_len == prntbuflen) { /* * Not enough room in the buffer */ prntbuflen += BUFSIZE; prntbuf = realloc(prntbuf, prntbuflen + 1); if (prntbuf == NULL) { (void) fprintf(stderr, gettext("%s: out of memory\n"), cmdname); exit(2); } } ptr = prntbuf; /* read the next input */ continue; } L_start_process: /* * Beginning of the chunk: ptr * End of the chunk: ptr + data_len * Beginning of the line: ptr * End of the line: ptrend */ if (use_bmg) { /* * Use Boyer-Moore-Gosper algorithm to find out if * this chunk (not this line) contains the specified * pattern. If not, restart from the last line * of this chunk. */ char *bline; bline = bmgexec(ptr, ptr + data_len); if (bline == NULL) { /* * No pattern found in this chunk. * Need to find the last line * in this chunk. */ ptrend = rfind_nl(ptr, data_len); /* * When this chunk does not contain newline, * ptrend becomes NULL, which should happen * when the last line of file does not end * with a newline. At such a point, * newlinep should have been set to 0. * Therefore, just after jumping to * L_skip_line, the main for-loop quits, * and the line_len value won't be * used. */ line_len = ptrend - ptr; goto L_skip_line; } if (bline > ptrend) { /* * Pattern found not in the first line * of this chunk. * Discard the first line. */ line_len = ptrend - ptr; goto L_skip_line; } /* * Pattern found in the first line of this chunk. * Using this result. */ *ptrend = '\0'; line_len = ptrend - ptr; /* * before jumping to L_next_line, * need to handle xflag if specified */ if (xflag && (line_len != bmglen || strcmp(bmgpat, ptr) != 0)) { /* didn't match */ pp = NULL; } else { pp = patterns; /* to make it happen */ } goto L_next_line; } lineno++; /* * Line starts from ptr and ends at ptrend. * line_len will be the length of the line. */ *ptrend = '\0'; line_len = ptrend - ptr; /* * From now, the process will be performed based * on the line from ptr to ptrend. */ if (use_wchar) { size_t len; if (line_len >= outbuflen) { outbuflen = line_len + 1; outline = realloc(outline, sizeof (wchar_t) * outbuflen); if (outline == NULL) { (void) fprintf(stderr, gettext("%s: out of memory\n"), cmdname); exit(2); } } len = mbstowcs(outline, ptr, line_len); if (len == (size_t)-1) { (void) fprintf(stderr, gettext( "%s: input file \"%s\": line %lld: invalid multibyte character\n"), cmdname, fn, lineno); /* never match a line with invalid sequence */ goto L_skip_line; } outline[len] = L'\0'; if (iflag) { wchar_t *cp; for (cp = outline; *cp != '\0'; cp++) { *cp = towlower((wint_t)*cp); } } if (xflag) { for (pp = patterns; pp; pp = pp->next) { if (outline[0] == pp->wpattern[0] && wcscmp(outline, pp->wpattern) == 0) { /* matched */ rv = REG_OK; break; } } } else { for (pp = patterns; pp; pp = pp->next) { if (wcswcs(outline, pp->wpattern) != NULL) { /* matched */ rv = REG_OK; break; } } } } else if (Fflag) { /* fgrep in byte-oriented handling */ char *fptr; if (iflag) { fptr = istrdup(ptr); } else { fptr = ptr; } if (xflag) { /* fgrep -x */ for (pp = patterns; pp; pp = pp->next) { if (fptr[0] == pp->pattern[0] && strcmp(fptr, pp->pattern) == 0) { /* matched */ rv = REG_OK; break; } } } else { for (pp = patterns; pp; pp = pp->next) { if (strstr(fptr, pp->pattern) != NULL) { /* matched */ rv = REG_OK; break; } } } } else { /* grep or egrep */ for (pp = patterns; pp; pp = pp->next) { rv = regexec(&pp->re, ptr, 0, NULL, 0); if (rv == REG_OK) { /* matched */ break; } switch (rv) { case REG_NOMATCH: break; case REG_ECHAR: (void) fprintf(stderr, gettext( "%s: input file \"%s\": line %lld: invalid multibyte character\n"), cmdname, fn, lineno); break; default: (void) regerror(rv, &pp->re, errstr, sizeof (errstr)); (void) fprintf(stderr, gettext( "%s: input file \"%s\": line %lld: %s\n"), cmdname, fn, lineno, errstr); exit(2); } } } /* * Context is set up as follows: * For a 'Before' context, we maintain a set of pointers * containing 'N' lines of context. If the current number of * lines contained is greater than N, and N isn't a match, the * start pointer is moved forward to the next newline. * * If we ever find a match, we print out immediately. * 'nearmatch' tells us if we're within N+1 lines of the last * match ; if we are, and we find another match, we don't * separate the matches. 'nearmatch' becomes false when * a line gets rotated out of the context. * * For an 'After' context, we simply wait until we've found a * match, then create a context N+1 lines big. If we don't find * a match within the context, we print out the current context. * Otherwise, we save a reference to the new matching line, * print out the other context, and reset our context pointers * to the new matching line. * * 'nearmatch' becomes false when we find a non-matching line * that isn't a part of any context. * * A full-context is implemented as a combination of the * 'Before' and 'After' context logic. Before we find a match, * we follow the Before logic. When we find a match, we * follow the After logic. 'nearmatch' is handled by the Before * logic. */ if (!conflag) goto L_next_line; if (line_len + (conptrend - conbuf) > conbuflen) { char *oldconbuf = conbuf; char *oldconptr = conptr; long tmp = matchptr - conptr; conbuflen += BUFSIZE; conbuf = realloc(conbuf, conbuflen + 1); if (conbuf == NULL) { (void) fprintf(stderr, gettext("%s: out of memory\n"), cmdname); exit(2); } conptr = conbuf + (conptr - oldconbuf); conptrend = conptr + (conptrend - oldconptr); if (matchptr) matchptr = conptr + tmp; } (void) memcpy((conptrend > conptr) ? conptrend + 1 : conptrend, ptr, line_len); conptrend += line_len + (conptrend > conptr); *conptrend = '\n'; if (!nvflag == rv) { /* matched */ if (lastmatch) { if (conflag & AFTER) { conaprnt = 1; nextend = conptrend; conptrend = conptr + lastmatch; nextptr = conptrend + 1; *nextend = '\n'; } } else { if (conflag == AFTER) { conptr = conptrend - (line_len); linenum = lineno; blkoffset = line_offset; } blkoffset = line_offset - (conptrend - conptr - line_len); } if (conflag == BEFORE) conbprnt = 1; lastmatch = conptrend - conptr; goto L_next_line; } if (!lastmatch) { if (conflag & BEFORE) { if (conbcnt >= conblen) { char *tmp = conptr; conptr = find_nl(conptr, conptrend - conptr) + 1; if (bflag) blkoffset += conptr - tmp; linenum++; nearmatch = 1; } else { conbcnt++; } } if (conflag == AFTER) nearmatch = 1; } else { if (++conacnt >= conalen && !conaprnt && conalen) conaprnt = 1; else lastmatch = conptrend - conptr; } L_next_line: /* * Here, if pp points to non-NULL, something has been matched * to the pattern. */ if (nvflag == (pp != NULL)) { matches++; if (!nextend) matchptr = conflag ? conptrend : ptrend; } /* * Set up some print context so that we can treat * single-line matches as a zero-N context. * Apply CLI flags to each line of the context. * * For context, we only print if we both have a match and are * either at the end of the data stream, or we've previously * declared that we want to print for a particular context. */ if (lastmatch && (eof || conaprnt || conbprnt)) { /* * We'd normally do this earlier, but we had to * escape early because we reached the end of the data. */ if (eof && nextptr) conptrend = nextend; prntlen = conptrend - conptr + 1; prntptrend = prntptr = conptr; if (conmatches++ && nearmatch && !cflag) (void) fwrite("--\n", 1, 3, stdout); } else if (!conflag && nvflag == (pp != NULL)) { *ptrend = '\n'; prntlen = line_len + 1; prntptrend = prntptr = ptr; linenum = lineno; blkoffset = line_offset; } else if (eof) { /* No match and no more data */ goto out; } else { /* No match, or we're not done building context */ goto L_skip_line; } while ((prntptrend = find_nl(prntptrend+1, prntlen)) != NULL) { /* * GNU grep uses '-' for context lines and ':' for * matching lines, so replicate that here. */ if (prntptrend == matchptr) { if (eof && nextptr) { matchptr = nextend; nextptr = NULL; } else { matchptr = NULL; } separate = ':'; } else { separate = '-'; } /* * Handle q, l, and c flags. */ if (qflag) { /* no need to continue */ /* * End of this line is ptrend. * We have read up to ptr + data_len. */ off_t pos; pos = ptr + data_len - (ptrend + 1); (void) lseek(fd, -pos, SEEK_CUR); exit(0); } if (lflag) { (void) printf("%s\n", fn); goto out; } if (!cflag) { if (Hflag || outfn) { (void) printf("%s%c", fn, separate); } if (bflag) { (void) printf("%lld%c", (offset_t) (blkoffset / BSIZE), separate); } if (nflag) { (void) printf("%lld%c", linenum, separate); } (void) fwrite(prntptr, 1, prntptrend - prntptr + 1, stdout); } if (ferror(stdout)) { return (0); } linenum++; prntlen -= prntptrend - prntptr + 1; blkoffset += prntptrend - prntptr + 1; prntptr = prntptrend + 1; } if (eof) goto out; /* * Update context buffer and variables post-print */ if (conflag) { conptr = conbuf; conaprnt = conbprnt = 0; nearmatch = 0; conacnt = conbcnt = 0; if (nextptr) { (void) memmove(conbuf, nextptr, nextend - nextptr + 1); blkoffset += nextptr - conptrend - 1; conptrend = conptr + (nextend - nextptr); matchptr = conptrend; linenum = lineno; lastmatch = conptrend - conptr; } else { conptrend = conptr; conacnt = 0; lastmatch = 0; } nextptr = nextend = NULL; } L_skip_line: if (!newlinep) break; data_len -= line_len + 1; line_offset += line_len + 1; ptr = ptrend + 1; } out: if (cflag) { if (Hflag || outfn) { (void) printf("%s:", fn); } if (!qflag) { (void) printf("%lld\n", matches); } } return (matches != 0); }
int APICaller::GetData(LPCWSTR path, char **dataOut) { char *readBuffer = NULL; DWORD cumulativeRead = 0; BOOL dataCompressed = FALSE; // Attempt to get a connection if (!GetConnection()) { return 0; } HINTERNET request = WinHttpOpenRequest(connection, L"GET", path, NULL, WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, WINHTTP_FLAG_SECURE); if (request != NULL) { WinHttpAddRequestHeaders(request, L"Accept-Encoding: gzip, deflate", (DWORD)-1, WINHTTP_ADDREQ_FLAG_ADD); if (WinHttpSendRequest(request, WINHTTP_NO_ADDITIONAL_HEADERS, 0, WINHTTP_NO_REQUEST_DATA, 0, 0, 0)) { if (WinHttpReceiveResponse(request, NULL)) { DWORD toRead = 0; DWORD bytesRead = 0; do { if (!WinHttpQueryDataAvailable(request, &toRead)) { break; } if (toRead == 0) { break; } readBuffer = (char*)((readBuffer == NULL) ? malloc(toRead) : realloc(readBuffer, cumulativeRead + toRead + 1)); if (WinHttpReadData(request, readBuffer+cumulativeRead, toRead, &bytesRead)) { cumulativeRead += bytesRead; } } while (toRead > 0); readBuffer[cumulativeRead] = '\0'; //get compression status WCHAR *headerInfo = GetHeader(request, WINHTTP_QUERY_CONTENT_ENCODING); dataCompressed = wcswcs(headerInfo, L"gzip") != NULL; delete[] headerInfo; } } WinHttpCloseHandle(request); } //Decompress data if necessary if (readBuffer != NULL && cumulativeRead > 0) { if (dataCompressed) { char *inflateBuffer = new char[cumulativeRead*50]; cumulativeRead = decompress(readBuffer, cumulativeRead, inflateBuffer, cumulativeRead*50); inflateBuffer[cumulativeRead] = NULL; *dataOut = inflateBuffer; } else { char *buffer = new char[cumulativeRead+1]; memcpy(buffer, readBuffer, cumulativeRead+1); *dataOut = buffer; } free(readBuffer); } return cumulativeRead; }