static const response* add(const char* l) { struct rule* r; if (*l != 'k' && *l != 'd' && *l != 'z' && *l != 'p' && *l != 'n') return 0; r = alloc_rule(); r->code = *l++; if ((l = parse_pattern(l, ':', &r->sender)) != 0 && *l == ':') if ((l = parse_pattern(l+1, ':', &r->recipient)) != 0 && *l == ':') if ((l = parse_str(l+1, ':', &r->response)) != 0 && *l == ':') if ((l = parse_uint(l+1, ':', &r->databytes)) != 0) if (*l == ':' && (l = parse_str(l+1, ':', &r->relayclient)) != 0 && *l == ':') parse_env(l+1, &r->environment); if (l == 0) return &resp_syntax; append_rule(r); /* Pre-load text files and pre-open CDB files */ if (!try_load(&r->sender)) return &resp_erropenref; if (!try_load(&r->recipient)) return &resp_erropenref; return 0; }
static void print_playing_song_default (DBusGProxy *shell_proxy, DBusGProxy *player_proxy) { gboolean errored; GHashTable *properties; char *string; GError *error = NULL; properties = get_playing_song_info (shell_proxy, player_proxy, &error); if (annoy (&error)) { return; } if (properties == NULL) { g_print ("%s\n", _("Not playing")); return; } if (g_hash_table_lookup (properties, "rb:stream-song-title") != NULL) { string = parse_pattern ("%st (%tt)", properties, 0); } else { string = parse_pattern ("%ta - %tt", properties, 0); } g_print ("%s\n", string); g_hash_table_destroy (properties); g_free (string); }
static void print_playing_song (GDBusProxy *mpris, const char *format) { GHashTable *properties; GVariant *v; gint64 elapsed = 0; char *string; properties = get_playing_song_info (mpris); if (properties == NULL) { g_print ("%s\n", _("Not playing")); return; } v = g_dbus_proxy_get_cached_property (mpris, "Position"); if (v != NULL) { elapsed = g_variant_get_int64 (v); g_variant_unref (v); } string = parse_pattern (format, properties, elapsed); g_print ("%s\n", string); g_hash_table_destroy (properties); g_free (string); }
static void print_playing_song (DBusGProxy *shell_proxy, DBusGProxy *player_proxy, const char *format) { gboolean errored; GHashTable *properties; guint elapsed = 0; GError *error = NULL; char *string; properties = get_playing_song_info (shell_proxy, player_proxy, &error); if (annoy (&error)) { return; } if (properties == NULL) { g_print ("%s\n", _("Not playing")); return; } org_gnome_Rhythmbox_Player_get_elapsed (player_proxy, &elapsed, &error); annoy (&error); string = parse_pattern (format, properties, elapsed); g_print ("%s\n", string); g_hash_table_destroy (properties); g_free (string); }
static int aio_write_f(int argc, char **argv) { int nr_iov, c; int pattern = 0xcd; struct aio_ctx *ctx = g_new0(struct aio_ctx, 1); while ((c = getopt(argc, argv, "CqP:")) != EOF) { switch (c) { case 'C': ctx->Cflag = 1; break; case 'q': ctx->qflag = 1; break; case 'P': pattern = parse_pattern(optarg); if (pattern < 0) { g_free(ctx); return 0; } break; default: g_free(ctx); return command_usage(&aio_write_cmd); } } if (optind > argc - 2) { g_free(ctx); return command_usage(&aio_write_cmd); } ctx->offset = cvtnum(argv[optind]); if (ctx->offset < 0) { printf("non-numeric length argument -- %s\n", argv[optind]); g_free(ctx); return 0; } optind++; if (ctx->offset & 0x1ff) { printf("offset %" PRId64 " is not sector aligned\n", ctx->offset); g_free(ctx); return 0; } nr_iov = argc - optind; ctx->buf = create_iovec(&ctx->qiov, &argv[optind], nr_iov, pattern); if (ctx->buf == NULL) { g_free(ctx); return 0; } gettimeofday(&ctx->t1, NULL); bdrv_aio_writev(bs, ctx->offset >> 9, &ctx->qiov, ctx->qiov.size >> 9, aio_write_done, ctx); return 0; }
int main(int argc, char *argv[]){ if (argc < 2){ printf("No pattern\n"); return -1; } struct RL* rl = rl_open(0,MAX_LEN); int i; char** patterns = malloc((argc-1)*sizeof(char*)); char** repls = malloc((argc-1)*sizeof(char*)); int* greeds = malloc((argc-1)*sizeof(int)); char* str; for (i = 1; i < argc; i++){ //get pattern strtok(argv[i], "/"); char* pattern_tmp = strtok(NULL, "/");//skip s/ patterns[i-1] = malloc(strlen(pattern_tmp)+1); strcpy(patterns[i-1], pattern_tmp); pattern_tmp = strtok(NULL, "/"); repls[i-1] = malloc(strlen(pattern_tmp)+1); strcpy(repls[i-1], pattern_tmp); greeds[i-1] = (strtok(NULL, "/") != NULL); //printf("%s\n%s\n%d\n", patterns[i-1], repls[i-1], greeds[i-1]); } //test int res = rl_readline(rl, rl->buf, rl->buf_size); while (res!=0){ if (res > 0){ //do shit and write //printf("%s",rl->buf); str = malloc((res+1)*sizeof(char)); strcpy(str,rl->buf); //printf("%s+%s\n", str,repls[i]); for (i = 0; i < argc-1; i++){ //if (parse_pattern(str,patterns[i],repls[i],greeds[i]) == NULL){ // printf("NO F**K YOU"); //} str = parse_pattern(str,patterns[i],repls[i],greeds[i]); } write(1,str,strlen(str)); write(1,"\n",1); free(str); } else { break; } res = rl_readline(rl, rl->buf,rl->buf_size); } for (i = 0; i < argc -1; i++){ free(patterns[i]); free(repls[i]); } free(patterns); free(repls); free(greeds); return 0; }
int parse_nf (char *string, List *list) { newts_nfref *ref = nfref_alloc (); char *copy; if (string == NULL || list == NULL) return -1; copy = newts_strdup (string); if (!pattern_flag) sense = PARSE_ADD; if (*copy == ':') { return parse_file (copy + 1, list); } if (*copy == '!') { char *change = newts_strdup (copy + 1); newts_free (copy); copy = change; sense = PARSE_DELETE; } if (!pattern_flag && (strchr (copy, '?') || strchr (copy, '[') || strchr (copy, '*') || strchr (copy, ' '))) { /* Pattern matching. */ int result; pattern_flag = TRUE; result = parse_pattern (copy, list); pattern_flag = FALSE; return result; } parse_single_nf (copy, ref); if (sense == PARSE_ADD) list_insert_next (list, list_tail (list), (void *) ref); else { list_remove_match (list, (void *) ref); nfref_free (ref); } newts_free (copy); return 0; }
static inline struct simple_pattern *parse_pattern(char *str, SIMPLE_PREFIX_MODE default_mode) { // fprintf(stderr, "PARSING PATTERN: '%s'\n", str); SIMPLE_PREFIX_MODE mode; struct simple_pattern *child = NULL; char *s = str, *c = str; // skip asterisks in front while(*c == '*') c++; // find the next asterisk while(*c && *c != '*') c++; // do we have an asterisk in the middle? if(*c == '*' && c[1] != '\0') { // yes, we have child = parse_pattern(c, default_mode); c[1] = '\0'; } // check what this one matches size_t len = strlen(s); if(len >= 2 && *s == '*' && s[len - 1] == '*') { s[len - 1] = '\0'; s++; mode = SIMPLE_PATTERN_SUBSTRING; } else if(len >= 1 && *s == '*') { s++; mode = SIMPLE_PATTERN_SUFFIX; } else if(len >= 1 && s[len - 1] == '*') { s[len - 1] = '\0'; mode = SIMPLE_PATTERN_PREFIX; } else mode = default_mode; // allocate the structure struct simple_pattern *m = callocz(1, sizeof(struct simple_pattern)); if(*s) { m->match = strdupz(s); m->len = strlen(m->match); m->mode = mode; } else { m->mode = SIMPLE_PATTERN_SUBSTRING; } m->child = child; return m; }
static void print_playing_song_default (GDBusProxy *mpris) { GHashTable *properties; char *string; properties = get_playing_song_info (mpris); if (properties == NULL) { g_print ("%s\n", _("Not playing")); return; } if (g_hash_table_lookup (properties, "rhythmbox:streamTitle") != NULL) { string = parse_pattern ("%st (%tt)", properties, 0); } else { string = parse_pattern ("%ta - %tt", properties, 0); } g_print ("%s\n", string); g_hash_table_destroy (properties); g_free (string); }
bregonig *recompile_onig(bregonig *rxold, pattern_type type, const TCHAR *ptn, TCHAR *msg) { const TCHAR *patternp; const TCHAR *patternendp; const TCHAR *prerepp; const TCHAR *prerependp; const TCHAR *optionp; const TCHAR *optionendp; TRACE1(_T("recompile_onig(): %s\n"), ptn); type = parse_pattern(ptn, type, &patternp, &patternendp, &prerepp, &prerependp, &optionp, &optionendp, msg); if (type == PTN_ERROR) { return NULL; } return recompile_onig_ex(rxold, type, ptn, patternp, patternendp, prerepp, prerependp, optionp, optionendp, msg); }
static int read_f(int argc, char **argv) { struct timeval t1, t2; int Cflag = 0, pflag = 0, qflag = 0, vflag = 0; int Pflag = 0, sflag = 0, lflag = 0, bflag = 0; int c, cnt; char *buf; int64_t offset; int count; /* Some compilers get confused and warn if this is not initialized. */ int total = 0; int pattern = 0, pattern_offset = 0, pattern_count = 0; while ((c = getopt(argc, argv, "bCl:pP:qs:v")) != EOF) { switch (c) { case 'b': bflag = 1; break; case 'C': Cflag = 1; break; case 'l': lflag = 1; pattern_count = cvtnum(optarg); if (pattern_count < 0) { printf("non-numeric length argument -- %s\n", optarg); return 0; } break; case 'p': pflag = 1; break; case 'P': Pflag = 1; pattern = parse_pattern(optarg); if (pattern < 0) { return 0; } break; case 'q': qflag = 1; break; case 's': sflag = 1; pattern_offset = cvtnum(optarg); if (pattern_offset < 0) { printf("non-numeric length argument -- %s\n", optarg); return 0; } break; case 'v': vflag = 1; break; default: return command_usage(&read_cmd); } } if (optind != argc - 2) { return command_usage(&read_cmd); } if (bflag && pflag) { printf("-b and -p cannot be specified at the same time\n"); return 0; } offset = cvtnum(argv[optind]); if (offset < 0) { printf("non-numeric length argument -- %s\n", argv[optind]); return 0; } optind++; count = cvtnum(argv[optind]); if (count < 0) { printf("non-numeric length argument -- %s\n", argv[optind]); return 0; } if (!Pflag && (lflag || sflag)) { return command_usage(&read_cmd); } if (!lflag) { pattern_count = count - pattern_offset; } if ((pattern_count < 0) || (pattern_count + pattern_offset > count)) { printf("pattern verification range exceeds end of read data\n"); return 0; } if (!pflag) { if (offset & 0x1ff) { printf("offset %" PRId64 " is not sector aligned\n", offset); return 0; } if (count & 0x1ff) { printf("count %d is not sector aligned\n", count); return 0; } } buf = qemu_io_alloc(count, 0xab); gettimeofday(&t1, NULL); if (pflag) { cnt = do_pread(buf, offset, count, &total); } else if (bflag) { cnt = do_load_vmstate(buf, offset, count, &total); } else { cnt = do_read(buf, offset, count, &total); } gettimeofday(&t2, NULL); if (cnt < 0) { printf("read failed: %s\n", strerror(-cnt)); goto out; } if (Pflag) { void *cmp_buf = g_malloc(pattern_count); memset(cmp_buf, pattern, pattern_count); if (memcmp(buf + pattern_offset, cmp_buf, pattern_count)) { printf("Pattern verification failed at offset %" PRId64 ", %d bytes\n", offset + pattern_offset, pattern_count); } g_free(cmp_buf); } if (qflag) { goto out; } if (vflag) { dump_buffer(buf, offset, count); } /* Finally, report back -- -C gives a parsable format */ t2 = tsub(t2, t1); print_report("read", &t2, offset, count, total, cnt, Cflag); out: qemu_io_free(buf); return 0; }
static int aio_read_f(int argc, char **argv) { int nr_iov, c; struct aio_ctx *ctx = calloc(1, sizeof(struct aio_ctx)); BlockDriverAIOCB *acb; while ((c = getopt(argc, argv, "CP:qv")) != EOF) { switch (c) { case 'C': ctx->Cflag = 1; break; case 'P': ctx->Pflag = 1; ctx->pattern = parse_pattern(optarg); if (ctx->pattern < 0) return 0; break; case 'q': ctx->qflag = 1; break; case 'v': ctx->vflag = 1; break; default: free(ctx); return command_usage(&aio_read_cmd); } } if (optind > argc - 2) { free(ctx); return command_usage(&aio_read_cmd); } ctx->offset = cvtnum(argv[optind]); if (ctx->offset < 0) { printf("non-numeric length argument -- %s\n", argv[optind]); free(ctx); return 0; } optind++; if (ctx->offset & 0x1ff) { printf("offset %" PRId64 " is not sector aligned\n", ctx->offset); free(ctx); return 0; } nr_iov = argc - optind; ctx->buf = create_iovec(&ctx->qiov, &argv[optind], nr_iov, 0xab); gettimeofday(&ctx->t1, NULL); acb = bdrv_aio_readv(bs, ctx->offset >> 9, &ctx->qiov, ctx->qiov.size >> 9, aio_read_done, ctx); if (!acb) { free(ctx->buf); free(ctx); return -EIO; } return 0; }
mod_export Cmatcher parse_cmatcher(char *name, char *s) { Cmatcher ret = NULL, r = NULL, n; Cpattern line, word, left, right; int fl, fl2, ll, wl, lal, ral, err, both; if (!*s) return NULL; while (*s) { lal = ral = both = fl2 = 0; left = right = NULL; while (*s && inblank(*s)) s++; if (!*s) break; switch (*s) { case 'b': fl2 = CMF_INTER; case 'l': fl = CMF_LEFT; break; case 'e': fl2 = CMF_INTER; case 'r': fl = CMF_RIGHT; break; case 'm': fl = 0; break; case 'B': fl2 = CMF_INTER; case 'L': fl = CMF_LEFT | CMF_LINE; break; case 'E': fl2 = CMF_INTER; case 'R': fl = CMF_RIGHT | CMF_LINE; break; case 'M': fl = CMF_LINE; break; default: if (name) zwarnnam(name, "unknown match specification character `%c'", *s); return pcm_err; } if (s[1] != ':') { if (name) zwarnnam(name, "missing `:'"); return pcm_err; } s += 2; if (!*s) { if (name) zwarnnam(name, "missing patterns"); return pcm_err; } if ((fl & CMF_LEFT) && !fl2) { left = parse_pattern(name, &s, &lal, '|', &err); if (err) return pcm_err; if ((both = (*s && s[1] == '|'))) s++; if (!*s || !*++s) { if (name) zwarnnam(name, "missing line pattern"); return pcm_err; } } else left = NULL; line = parse_pattern(name, &s, &ll, (((fl & CMF_RIGHT) && !fl2) ? '|' : '='), &err); if (err) return pcm_err; if (both) { right = line; ral = ll; line = NULL; ll = 0; } if ((fl & CMF_RIGHT) && !fl2 && (!*s || !*++s)) { if (name) zwarnnam(name, "missing right anchor"); } else if (!(fl & CMF_RIGHT) || fl2) { if (!*s) { if (name) zwarnnam(name, "missing word pattern"); return pcm_err; } s++; } if ((fl & CMF_RIGHT) && !fl2) { if (*s == '|') { left = line; lal = ll; line = NULL; ll = 0; s++; } right = parse_pattern(name, &s, &ral, '=', &err); if (err) return pcm_err; if (!*s) { if (name) zwarnnam(name, "missing word pattern"); return pcm_err; } s++; } else right = NULL; if (*s == '*') { if (!(fl & (CMF_LEFT | CMF_RIGHT))) { if (name) zwarnnam(name, "need anchor for `*'"); return pcm_err; } word = NULL; if (*++s == '*') { s++; wl = -2; } else wl = -1; } else { word = parse_pattern(name, &s, &wl, 0, &err); if (!word && !line) { if (name) zwarnnam(name, "need non-empty word or line pattern"); return pcm_err; } } if (err) return pcm_err; n = (Cmatcher) hcalloc(sizeof(*ret)); n->next = NULL; n->flags = fl | fl2; n->line = line; n->llen = ll; n->word = word; n->wlen = wl; n->left = left; n->lalen = lal; n->right = right; n->ralen = ral; if (ret) r->next = n; else ret = n; r = n; } return ret; }
static int writev_f(int argc, char **argv) { struct timeval t1, t2; int Cflag = 0, qflag = 0; int c, cnt; char *buf; int64_t offset; /* Some compilers get confused and warn if this is not initialized. */ int total = 0; int nr_iov; int pattern = 0xcd; QEMUIOVector qiov; while ((c = getopt(argc, argv, "CqP:")) != EOF) { switch (c) { case 'C': Cflag = 1; break; case 'q': qflag = 1; break; case 'P': pattern = parse_pattern(optarg); if (pattern < 0) { return 0; } break; default: return command_usage(&writev_cmd); } } if (optind > argc - 2) { return command_usage(&writev_cmd); } offset = cvtnum(argv[optind]); if (offset < 0) { printf("non-numeric length argument -- %s\n", argv[optind]); return 0; } optind++; if (offset & 0x1ff) { printf("offset %" PRId64 " is not sector aligned\n", offset); return 0; } nr_iov = argc - optind; buf = create_iovec(&qiov, &argv[optind], nr_iov, pattern); if (buf == NULL) { return 0; } gettimeofday(&t1, NULL); cnt = do_aio_writev(&qiov, offset, &total); gettimeofday(&t2, NULL); if (cnt < 0) { printf("writev failed: %s\n", strerror(-cnt)); goto out; } if (qflag) { goto out; } /* Finally, report back -- -C gives a parsable format */ t2 = tsub(t2, t1); print_report("wrote", &t2, offset, qiov.size, total, cnt, Cflag); out: qemu_iovec_destroy(&qiov); qemu_io_free(buf); return 0; }
static int multiwrite_f(int argc, char **argv) { struct timeval t1, t2; int Cflag = 0, qflag = 0; int c, cnt; char **buf; int64_t offset, first_offset = 0; int total = 0; int nr_iov; int nr_reqs; int pattern = 0xcd; QEMUIOVector *qiovs; int i; BlockRequest *reqs; while ((c = getopt(argc, argv, "CqP:")) != EOF) { switch (c) { case 'C': Cflag = 1; break; case 'q': qflag = 1; break; case 'P': pattern = parse_pattern(optarg); if (pattern < 0) return 0; break; default: return command_usage(&writev_cmd); } } if (optind > argc - 2) return command_usage(&writev_cmd); nr_reqs = 1; for (i = optind; i < argc; i++) { if (!strcmp(argv[i], ";")) { nr_reqs++; } } reqs = qemu_malloc(nr_reqs * sizeof(*reqs)); buf = qemu_malloc(nr_reqs * sizeof(*buf)); qiovs = qemu_malloc(nr_reqs * sizeof(*qiovs)); for (i = 0; i < nr_reqs; i++) { int j; offset = cvtnum(argv[optind]); if (offset < 0) { printf("non-numeric offset argument -- %s\n", argv[optind]); return 0; } optind++; if (offset & 0x1ff) { printf("offset %lld is not sector aligned\n", (long long)offset); return 0; } if (i == 0) { first_offset = offset; } for (j = optind; j < argc; j++) { if (!strcmp(argv[j], ";")) { break; } } nr_iov = j - optind; reqs[i].qiov = &qiovs[i]; buf[i] = create_iovec(reqs[i].qiov, &argv[optind], nr_iov, pattern); reqs[i].sector = offset >> 9; reqs[i].nb_sectors = reqs[i].qiov->size >> 9; optind = j + 1; offset += reqs[i].qiov->size; pattern++; } gettimeofday(&t1, NULL); cnt = do_aio_multiwrite(reqs, nr_reqs, &total); gettimeofday(&t2, NULL); if (cnt < 0) { printf("aio_multiwrite failed: %s\n", strerror(-cnt)); goto out; } if (qflag) goto out; t2 = tsub(t2, t1); print_report("wrote", &t2, first_offset, total, total, cnt, Cflag); out: for (i = 0; i < nr_reqs; i++) { qemu_io_free(buf[i]); qemu_iovec_destroy(&qiovs[i]); } qemu_free(buf); qemu_free(reqs); qemu_free(qiovs); return 0; }
static int write_f(int argc, char **argv) { struct timeval t1, t2; int Cflag = 0, pflag = 0, qflag = 0, bflag = 0; int c, cnt; char *buf; int64_t offset; int count; int total = 0; int pattern = 0xcd; while ((c = getopt(argc, argv, "bCpP:q")) != EOF) { switch (c) { case 'b': bflag = 1; break; case 'C': Cflag = 1; break; case 'p': pflag = 1; break; case 'P': pattern = parse_pattern(optarg); if (pattern < 0) return 0; break; case 'q': qflag = 1; break; default: return command_usage(&write_cmd); } } if (optind != argc - 2) return command_usage(&write_cmd); if (bflag && pflag) { printf("-b and -p cannot be specified at the same time\n"); return 0; } offset = cvtnum(argv[optind]); if (offset < 0) { printf("non-numeric length argument -- %s\n", argv[optind]); return 0; } optind++; count = cvtnum(argv[optind]); if (count < 0) { printf("non-numeric length argument -- %s\n", argv[optind]); return 0; } if (!pflag) { if (offset & 0x1ff) { printf("offset %" PRId64 " is not sector aligned\n", offset); return 0; } if (count & 0x1ff) { printf("count %d is not sector aligned\n", count); return 0; } } buf = qemu_io_alloc(count, pattern); gettimeofday(&t1, NULL); if (pflag) cnt = do_pwrite(buf, offset, count, &total); else if (bflag) cnt = do_save_vmstate(buf, offset, count, &total); else cnt = do_write(buf, offset, count, &total); gettimeofday(&t2, NULL); if (cnt < 0) { printf("write failed: %s\n", strerror(-cnt)); goto out; } if (qflag) goto out; t2 = tsub(t2, t1); print_report("wrote", &t2, offset, count, total, cnt, Cflag); out: qemu_io_free(buf); return 0; }
SIMPLE_PATTERN *simple_pattern_create(const char *list, const char *separators, SIMPLE_PREFIX_MODE default_mode) { struct simple_pattern *root = NULL, *last = NULL; if(unlikely(!list || !*list)) return root; int isseparator[256] = { [' '] = 1 // space , ['\t'] = 1 // tab , ['\r'] = 1 // carriage return , ['\n'] = 1 // new line , ['\f'] = 1 // form feed , ['\v'] = 1 // vertical tab }; if (unlikely(separators && *separators)) { memset(&isseparator[0], 0, sizeof(isseparator)); while(*separators) isseparator[(unsigned char)*separators++] = 1; } char *buf = mallocz(strlen(list) + 1); const char *s = list; while(s && *s) { buf[0] = '\0'; char *c = buf; char negative = 0; // skip all spaces while(isseparator[(unsigned char)*s]) s++; if(*s == '!') { negative = 1; s++; } // empty string if(unlikely(!*s)) break; // find the next space char escape = 0; while(*s) { if(*s == '\\' && !escape) { escape = 1; s++; } else { if (isseparator[(unsigned char)*s] && !escape) { s++; break; } *c++ = *s++; escape = 0; } } // terminate our string *c = '\0'; // if we matched the empty string, skip it if(unlikely(!*buf)) continue; // fprintf(stderr, "FOUND PATTERN: '%s'\n", buf); struct simple_pattern *m = parse_pattern(buf, default_mode); m->negative = negative; // link it at the end if(unlikely(!root)) root = last = m; else { last->next = m; last = m; } } freez(buf); return (SIMPLE_PATTERN *)root; }
static int readv_f(int argc, char **argv) { struct timeval t1, t2; int Cflag = 0, qflag = 0, vflag = 0; int c, cnt; char *buf; int64_t offset; /* Some compilers get confused and warn if this is not initialized. */ int total = 0; int nr_iov; QEMUIOVector qiov; int pattern = 0; int Pflag = 0; while ((c = getopt(argc, argv, "CP:qv")) != EOF) { switch (c) { case 'C': Cflag = 1; break; case 'P': Pflag = 1; pattern = parse_pattern(optarg); if (pattern < 0) { return 0; } break; case 'q': qflag = 1; break; case 'v': vflag = 1; break; default: return command_usage(&readv_cmd); } } if (optind > argc - 2) { return command_usage(&readv_cmd); } offset = cvtnum(argv[optind]); if (offset < 0) { printf("non-numeric length argument -- %s\n", argv[optind]); return 0; } optind++; if (offset & 0x1ff) { printf("offset %" PRId64 " is not sector aligned\n", offset); return 0; } nr_iov = argc - optind; buf = create_iovec(&qiov, &argv[optind], nr_iov, 0xab); if (buf == NULL) { return 0; } gettimeofday(&t1, NULL); cnt = do_aio_readv(&qiov, offset, &total); gettimeofday(&t2, NULL); if (cnt < 0) { printf("readv failed: %s\n", strerror(-cnt)); goto out; } if (Pflag) { void *cmp_buf = g_malloc(qiov.size); memset(cmp_buf, pattern, qiov.size); if (memcmp(buf, cmp_buf, qiov.size)) { printf("Pattern verification failed at offset %" PRId64 ", %zd bytes\n", offset, qiov.size); } g_free(cmp_buf); } if (qflag) { goto out; } if (vflag) { dump_buffer(buf, offset, qiov.size); } /* Finally, report back -- -C gives a parsable format */ t2 = tsub(t2, t1); print_report("read", &t2, offset, qiov.size, total, cnt, Cflag); out: qemu_iovec_destroy(&qiov); qemu_io_free(buf); return 0; }
int main(int argc, char *argv[]) { int leadin = 0, leadout = 0; const char *avifile = NULL; pattern_data *pattern = NULL; int patcount = 0; int arg; int i; /* iterate over arguments */ for (arg = 1; arg < argc; arg++) { /* assume anything without a - is a filename */ if (argv[arg][0] != '-') { if (avifile != NULL || pattern != NULL) return usage(); avifile = argv[arg]; } /* look for options */ else if (strcmp(argv[arg], "-leadin") == 0) { if (++arg >= argc) return usage(); leadin = atoi(argv[arg]); } else if (strcmp(argv[arg], "-leadout") == 0) { if (++arg >= argc) return usage(); leadout = atoi(argv[arg]); } else if (strcmp(argv[arg], "-pattern") == 0) { if (avifile != NULL || pattern != NULL) return usage(); if (++arg >= argc) return usage(); pattern = parse_pattern(argv[arg], &patcount); if (pattern == NULL) return usage(); } } /* must have an AVI file or a pattern */ if (avifile == NULL && pattern == NULL) return usage(); /* output header and leadin */ printf("chdmeta 12\n"); for (i = 0; i < leadin; i++) { int flags = (i == 0) ? 0x02 : (i == leadin - 1) ? 0x01 : 0x03; printf("02%02X%02X00000088FFFF88FFFF\n", flags, (i % 2)); } /* if we got a file, output it */ if (avifile != NULL) generate_from_avi(avifile); else if (pattern != NULL) generate_from_pattern(pattern, patcount); /* output leadout */ for (i = 0; i < leadout; i++) { int flags = (i == 0) ? 0x02 : (i == leadout - 1) ? 0x01 : 0x03; printf("02%02X%02X00000080EEEE80EEEE\n", flags, (i % 2)); } return 0; }
static int write_f(int argc, char **argv) { struct timeval t1, t2; int Cflag = 0, pflag = 0, qflag = 0, bflag = 0, Pflag = 0, zflag = 0; int cflag = 0; int c, cnt; char *buf = NULL; int64_t offset; int count; /* Some compilers get confused and warn if this is not initialized. */ int total = 0; int pattern = 0xcd; while ((c = getopt(argc, argv, "bcCpP:qz")) != EOF) { switch (c) { case 'b': bflag = 1; break; case 'c': cflag = 1; break; case 'C': Cflag = 1; break; case 'p': pflag = 1; break; case 'P': Pflag = 1; pattern = parse_pattern(optarg); if (pattern < 0) { return 0; } break; case 'q': qflag = 1; break; case 'z': zflag = 1; break; default: return command_usage(&write_cmd); } } if (optind != argc - 2) { return command_usage(&write_cmd); } if (bflag + pflag + zflag > 1) { printf("-b, -p, or -z cannot be specified at the same time\n"); return 0; } if (zflag && Pflag) { printf("-z and -P cannot be specified at the same time\n"); return 0; } offset = cvtnum(argv[optind]); if (offset < 0) { printf("non-numeric length argument -- %s\n", argv[optind]); return 0; } optind++; count = cvtnum(argv[optind]); if (count < 0) { printf("non-numeric length argument -- %s\n", argv[optind]); return 0; } if (!pflag) { if (offset & 0x1ff) { printf("offset %" PRId64 " is not sector aligned\n", offset); return 0; } if (count & 0x1ff) { printf("count %d is not sector aligned\n", count); return 0; } } if (!zflag) { buf = qemu_io_alloc(count, pattern); } gettimeofday(&t1, NULL); if (pflag) { cnt = do_pwrite(buf, offset, count, &total); } else if (bflag) { cnt = do_save_vmstate(buf, offset, count, &total); } else if (zflag) { cnt = do_co_write_zeroes(offset, count, &total); } else if (cflag) { cnt = do_write_compressed(buf, offset, count, &total); } else { cnt = do_write(buf, offset, count, &total); } gettimeofday(&t2, NULL); if (cnt < 0) { printf("write failed: %s\n", strerror(-cnt)); goto out; } if (qflag) { goto out; } /* Finally, report back -- -C gives a parsable format */ t2 = tsub(t2, t1); print_report("wrote", &t2, offset, count, total, cnt, Cflag); out: if (!zflag) { qemu_io_free(buf); } return 0; }
static struct Pattern * parse_pattern (unsigned pattern_index, struct Token *token_list, DskMemPool *pool, DskError **error) { dsk_boolean last_was_alter; dsk_boolean accept_empty; /* Handle parens */ struct Token *token; for (token = token_list; token; token = token->next) if (token->type == TOKEN_LPAREN) { /* find matching rparen (or error) */ struct Token *rparen = token->next; int balance = 1; struct Pattern *subpattern; while (rparen) { if (rparen->type == TOKEN_LPAREN) balance++; else if (rparen->type == TOKEN_RPAREN) { balance--; if (balance == 0) break; } rparen = rparen->next; } if (balance) { /* missing right-paren */ dsk_set_error (error, "missing right-paren in regex"); return NULL; } /* recurse */ rparen->prev->next = NULL; subpattern = parse_pattern (pattern_index, token->next, pool, error); if (subpattern == NULL) return NULL; /* replace parenthesized expr with subpattern; slice out remainder of list */ token->type = TOKEN_PATTERN; token->pattern = subpattern; token->next = rparen->next; if (rparen->next) token->next->prev = token; } else if (token->type == TOKEN_RPAREN) { dsk_set_error (error, "unexpected right-paren in regex"); return NULL; } /* Handle star/plus/qm */ for (token = token_list; token; token = token->next) if (token->type == TOKEN_QUESTION_MARK || token->type == TOKEN_STAR || token->type == TOKEN_PLUS) { struct Pattern *new_pattern; if (token->prev == NULL || token->prev->type != TOKEN_PATTERN) { dsk_set_error (error, "'%c' must be precede by pattern", token->type == TOKEN_QUESTION_MARK ? '?' : token->type == TOKEN_STAR ? '*' : '+'); return NULL; } new_pattern = dsk_mem_pool_alloc (pool, sizeof (struct Pattern)); switch (token->type) { case TOKEN_QUESTION_MARK: new_pattern->type = PATTERN_OPTIONAL; new_pattern->info.optional = token->prev->pattern; break; case TOKEN_STAR: new_pattern->type = PATTERN_STAR; new_pattern->info.star = token->prev->pattern; break; case TOKEN_PLUS: new_pattern->type = PATTERN_PLUS; new_pattern->info.plus = token->prev->pattern; break; default: dsk_assert_not_reached (); } token->prev->pattern = new_pattern; /* remove token */ if (token->prev) token->prev->next = token->next; else token_list = token->next; if (token->next) token->next->prev = token->prev; /* token isn't in the list now! but it doesn't matter b/c token->next is still correct */ } /* Handle concatenation */ for (token = token_list; token && token->next; ) { if (token->type == TOKEN_PATTERN && token->next->type == TOKEN_PATTERN) { /* concat */ struct Pattern *new_pattern = dsk_mem_pool_alloc (pool, sizeof (struct Pattern)); struct Token *kill; new_pattern->type = PATTERN_CONCAT; new_pattern->info.concat.a = token->pattern; new_pattern->info.concat.b = token->next->pattern; token->pattern = new_pattern; /* remove token->next */ kill = token->next; token->next = kill->next; if (kill->next) kill->next->prev = token; } else token = token->next; } /* At this point we consist of nothing but alternations and patterns. Scan through, discarding TOKEN_ALTER, and keeping track of whether the empty pattern matches */ last_was_alter = DSK_TRUE; /* trick the empty pattern detector into triggering on initial '|' */ accept_empty = DSK_FALSE; for (token = token_list; token; token = token->next) if (token->type == TOKEN_ALTER) { if (last_was_alter) accept_empty = DSK_TRUE; last_was_alter = DSK_TRUE; /* remove token from list */ if (token->prev) token->prev->next = token->next; else token_list = token->next; if (token->next) token->next->prev = token->prev; } else { last_was_alter = DSK_FALSE; } if (last_was_alter) accept_empty = DSK_TRUE; /* if we accept an empty token, toss a PATTERN_EMPTY onto the list of patterns in the alternation. */ if (accept_empty || token_list == NULL) { struct Token *t = dsk_mem_pool_alloc (pool, sizeof (struct Token)); t->next = token_list; t->prev = NULL; if (t->next) t->next->prev = t; token_list = t; t->type = TOKEN_PATTERN; t->pattern = dsk_mem_pool_alloc (pool, sizeof (struct Pattern)); } /* At this point, token_list!=NULL, and it consists entirely of patterns. Reduce it to a singleton with the alternation pattern. */ while (token_list->next != NULL) { /* create alternation pattern */ struct Pattern *new_pattern = dsk_mem_pool_alloc (pool, sizeof (struct Pattern)); new_pattern->type = PATTERN_ALT; new_pattern->info.alternation.a = token_list->pattern; new_pattern->info.alternation.b = token_list->next->pattern; token_list->pattern = new_pattern; /* remove token->next */ { struct Token *kill = token_list->next; token_list->next = kill->next; if (kill->next) kill->next->prev = token_list; } } /* Return value consists of merely a single token-list. */ dsk_assert (token_list != NULL && token_list->next == NULL); return token_list->pattern; }
static int multiwrite_f(int argc, char **argv) { struct timeval t1, t2; int Cflag = 0, qflag = 0; int c, cnt; char **buf; int64_t offset, first_offset = 0; /* Some compilers get confused and warn if this is not initialized. */ int total = 0; int nr_iov; int nr_reqs; int pattern = 0xcd; QEMUIOVector *qiovs; int i; BlockRequest *reqs; while ((c = getopt(argc, argv, "CqP:")) != EOF) { switch (c) { case 'C': Cflag = 1; break; case 'q': qflag = 1; break; case 'P': pattern = parse_pattern(optarg); if (pattern < 0) { return 0; } break; default: return command_usage(&writev_cmd); } } if (optind > argc - 2) { return command_usage(&writev_cmd); } nr_reqs = 1; for (i = optind; i < argc; i++) { if (!strcmp(argv[i], ";")) { nr_reqs++; } } reqs = g_malloc0(nr_reqs * sizeof(*reqs)); buf = g_malloc0(nr_reqs * sizeof(*buf)); qiovs = g_malloc(nr_reqs * sizeof(*qiovs)); for (i = 0; i < nr_reqs && optind < argc; i++) { int j; /* Read the offset of the request */ offset = cvtnum(argv[optind]); if (offset < 0) { printf("non-numeric offset argument -- %s\n", argv[optind]); goto out; } optind++; if (offset & 0x1ff) { printf("offset %lld is not sector aligned\n", (long long)offset); goto out; } if (i == 0) { first_offset = offset; } /* Read lengths for qiov entries */ for (j = optind; j < argc; j++) { if (!strcmp(argv[j], ";")) { break; } } nr_iov = j - optind; /* Build request */ buf[i] = create_iovec(&qiovs[i], &argv[optind], nr_iov, pattern); if (buf[i] == NULL) { goto out; } reqs[i].qiov = &qiovs[i]; reqs[i].sector = offset >> 9; reqs[i].nb_sectors = reqs[i].qiov->size >> 9; optind = j + 1; pattern++; } /* If there were empty requests at the end, ignore them */ nr_reqs = i; gettimeofday(&t1, NULL); cnt = do_aio_multiwrite(reqs, nr_reqs, &total); gettimeofday(&t2, NULL); if (cnt < 0) { printf("aio_multiwrite failed: %s\n", strerror(-cnt)); goto out; } if (qflag) { goto out; } /* Finally, report back -- -C gives a parsable format */ t2 = tsub(t2, t1); print_report("wrote", &t2, first_offset, total, total, cnt, Cflag); out: for (i = 0; i < nr_reqs; i++) { qemu_io_free(buf[i]); if (reqs[i].qiov != NULL) { qemu_iovec_destroy(&qiovs[i]); } } g_free(buf); g_free(reqs); g_free(qiovs); return 0; }
int parse_rule_content(char* rule) { if(rule == NULL) return -1; char* index = rule; char** toks; int i; // j; int num_toks; // int ruletype; int level; rule_node_t rule_node[10]; //每一行内容可能包含多个content int rule_num = 0; memset(&rule_node, 0, sizeof(rule_node_t)*10); while(*index == ' ' || *index =='\t') index++; for(i=0; i<strlen(index); i++) { if(*(index+i) == '\n') { *(index+i) = 0x00; break; } } toks = m_split(index, ";", PARSERULE_SIZE, &num_toks, 0); for(i=0; i<num_toks; i++) { char key[PARSERULE_SIZE]={0}; char value[PARSERULE_SIZE]={0}; char* idx; idx = toks[i]; while(*idx == ' ' || *idx == '\t') idx++; if(*idx == '\n' || *idx == 0x00) //是否是最后一个元素,即换行符 break; if(parse_key_value_pair(idx, key, value) < 0) { save_err_log("profile %s, line:%d, this line is not in the expected format", file_name, file_line); exit(1); } if(!strcmp(key, "classtype")) { strcpy(rule_node[0].type, value); } else if(!strcmp(key, "level")) { level = rule_level(value); if(level < 0) { m_split_free(&toks, num_toks); return -1; } rule_node[0].level = level; } else if(!strcmp(key, "msg")) { strcpy(rule_node[0].msg, value); } else if(!strcmp(key, "content") || !strcmp(key, "uricontent")) { if(parse_pattern(value, rule_node[rule_num].content, &rule_node[rule_num].content_len)<0) { save_err_log("profile %s, line:%d, this line is not in the expected format", file_name, file_line); m_split_free(&toks, num_toks); return -1; } rule_num++; } } for(i=0; i<rule_num; i++) { rule_node[i].nocase = NOCASE; rule_node[i].id = rule_id++; strcpy(rule_node[i].file_name, file_name); rule_node[i].file_line = file_line; if(i != 0) { strcpy(rule_node[i].type, rule_node[0].type); rule_node[i].level = rule_node[0].level; strcpy(rule_node[i].msg, rule_node[0].msg); } } m_split_free(&toks, num_toks); if(rule_node[0].content_len > 0 && rule_num >= 1) { rule_node_t* cur_rule_node = &rule_node[0]; if(rule_num == 1) { fpdetect_add_rule(cur_rule_node); } else { int j=1; for(j=1; j<rule_num; j++) { cur_rule_node = &rule_node[j]; if(cur_rule_node->content_len > 0) fpdetect_add_rule(cur_rule_node); } } } return 0; }