Adding upstream version 3.1.0+dfsg.
Signed-off-by: Daniel Baumann <daniel@debian.org>
This commit is contained in:
parent
64dbec996d
commit
cfcebb1a7d
GPG key ID:
FBB4F0E80A80222F
569 changed files with 205393 additions and 0 deletions
461
tools/re/main.c
Normal file
461
tools/re/main.c
Normal file
|
|
@ -0,0 +1,461 @@
|
|||
/**
|
||||
* @file main.c
|
||||
* @author Radek Krejci <rkrejci@cesnet.cz>
|
||||
* @author Adam Piecek <piecek@cesnet.cz>
|
||||
* @brief libyang's YANG Regular Expression tool
|
||||
*
|
||||
* Copyright (c) 2017 CESNET, z.s.p.o.
|
||||
*
|
||||
* This source code is licensed under BSD 3-Clause License (the "License").
|
||||
* You may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* https://opensource.org/licenses/BSD-3-Clause
|
||||
*/
|
||||
|
||||
#define _GNU_SOURCE /* asprintf, strdup */
|
||||
|
||||
#include <errno.h>
|
||||
#include <getopt.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
#include "libyang.h"
|
||||
|
||||
#include "compat.h"
|
||||
#include "tools/config.h"
|
||||
|
||||
struct yr_pattern {
|
||||
char *expr;
|
||||
ly_bool invert;
|
||||
};
|
||||
|
||||
void
|
||||
help(void)
|
||||
{
|
||||
fprintf(stdout, "YANG Regular Expressions processor.\n");
|
||||
fprintf(stdout, "Usage:\n");
|
||||
fprintf(stdout, " yangre [-hv]\n");
|
||||
fprintf(stdout, " yangre [-V] -p <regexp1> [-i] [-p <regexp2> [-i] ...] <string>\n");
|
||||
fprintf(stdout, " yangre [-V] -f <file>\n");
|
||||
fprintf(stdout, "Returns 0 if string matches the pattern(s) or if otherwise successful.\n");
|
||||
fprintf(stdout, "Returns 1 on error.\n");
|
||||
fprintf(stdout, "Returns 2 if string does not match the pattern(s).\n\n");
|
||||
fprintf(stdout, "Options:\n"
|
||||
" -h, --help Show this help message and exit.\n"
|
||||
" -v, --version Show version number and exit.\n"
|
||||
" -V, --verbose Print the processing information.\n"
|
||||
" -i, --invert-match Invert-match modifier for the closest preceding\n"
|
||||
" pattern.\n"
|
||||
" -p, --pattern=\"REGEXP\" Regular expression including the quoting,\n"
|
||||
" which is applied the same way as in a YANG module.\n"
|
||||
" -f, --file=\"FILE\" List of patterns and the <string> (separated by an\n"
|
||||
" empty line) are taken from <file>. Invert-match is\n"
|
||||
" indicated by the single space character at the \n"
|
||||
" beginning of the pattern line. YANG quotation around\n"
|
||||
" patterns is still expected, but that avoids issues with\n"
|
||||
" reading quotation by shell. Avoid newline at the end\n"
|
||||
" of the string line to represent empty <string>.");
|
||||
fprintf(stdout, "Examples:\n"
|
||||
" pattern \"[0-9a-fA-F]*\"; -> yangre -p '\"[0-9a-fA-F]*\"' '1F'\n"
|
||||
" pattern '[a-zA-Z0-9\\-_.]*'; -> yangre -p \"'[a-zA-Z0-9\\-_.]*'\" 'a-b'\n"
|
||||
" pattern [xX][mM][lL].*; -> yangre -p '[xX][mM][lL].*' 'xml-encoding'\n\n");
|
||||
fprintf(stdout, "Note that to pass YANG quoting through your shell, you are supposed to use\n"
|
||||
"the other quotation around. For not-quoted patterns, use single quotes.\n\n");
|
||||
}
|
||||
|
||||
void
|
||||
version(void)
|
||||
{
|
||||
fprintf(stdout, "yangre %s\n", PROJECT_VERSION);
|
||||
}
|
||||
|
||||
void
|
||||
pattern_error(LY_LOG_LEVEL level, const char *msg, const char *UNUSED(data_path), const char *UNUSED(schema_path),
|
||||
uint64_t UNUSED(line))
|
||||
{
|
||||
if (level == LY_LLERR) {
|
||||
fprintf(stderr, "yangre error: %s\n", msg);
|
||||
}
|
||||
}
|
||||
|
||||
static int
|
||||
add_pattern(struct yr_pattern **patterns, int *counter, char *pattern)
|
||||
{
|
||||
void *reallocated;
|
||||
int orig_counter;
|
||||
|
||||
/* Store the original number of items. */
|
||||
orig_counter = *counter;
|
||||
|
||||
/* Reallocate 'patterns' memory with additional space. */
|
||||
reallocated = realloc(*patterns, (orig_counter + 1) * sizeof **patterns);
|
||||
if (!reallocated) {
|
||||
goto error;
|
||||
}
|
||||
(*patterns) = reallocated;
|
||||
/* Allocated memory is now larger. */
|
||||
(*counter)++;
|
||||
/* Copy the pattern and store it to the additonal space. */
|
||||
(*patterns)[orig_counter].expr = strdup(pattern);
|
||||
if (!(*patterns)[orig_counter].expr) {
|
||||
goto error;
|
||||
}
|
||||
(*patterns)[orig_counter].invert = 0;
|
||||
|
||||
return 0;
|
||||
|
||||
error:
|
||||
fprintf(stderr, "yangre error: memory allocation error.\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int
|
||||
create_empty_string(char **str)
|
||||
{
|
||||
free(*str);
|
||||
*str = malloc(sizeof(char));
|
||||
if (!(*str)) {
|
||||
fprintf(stderr, "yangre error: memory allocation failed.\n");
|
||||
return 1;
|
||||
}
|
||||
(*str)[0] = '\0';
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static ly_bool
|
||||
file_is_empty(FILE *fp)
|
||||
{
|
||||
int c;
|
||||
|
||||
c = fgetc(fp);
|
||||
if (c == EOF) {
|
||||
return 1;
|
||||
} else {
|
||||
ungetc(c, fp);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Open the @p filepath, parse patterns and given string-argument.
|
||||
*
|
||||
* @param[in] filepath File to parse. Contains patterns and string.
|
||||
* @param[out] infile The file descriptor of @p filepath.
|
||||
* @param[out] patterns Storage of patterns.
|
||||
* @param[out] patterns_count Number of items in @p patterns.
|
||||
* @param[out] strarg The string-argument to check.
|
||||
* @return 0 on success.
|
||||
*/
|
||||
static int
|
||||
parse_patterns_file(const char *filepath, FILE **infile, struct yr_pattern **patterns, int *patterns_count, char **strarg)
|
||||
{
|
||||
int blankline = 0;
|
||||
char *str = NULL;
|
||||
size_t len = 0;
|
||||
ssize_t l;
|
||||
|
||||
*infile = fopen(filepath, "rb");
|
||||
if (!(*infile)) {
|
||||
fprintf(stderr, "yangre error: unable to open input file %s (%s).\n", optarg, strerror(errno));
|
||||
goto error;
|
||||
}
|
||||
if (file_is_empty(*infile)) {
|
||||
if (create_empty_string(strarg)) {
|
||||
goto error;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
while ((l = getline(&str, &len, *infile)) != -1) {
|
||||
if (!blankline && ((str[0] == '\n') || ((str[0] == '\r') && (str[1] == '\n')))) {
|
||||
/* blank line */
|
||||
blankline = 1;
|
||||
continue;
|
||||
}
|
||||
if ((str[0] != '\n') && (str[0] != '\r') && (str[l - 1] == '\n')) {
|
||||
/* remove ending newline */
|
||||
if ((l > 1) && (str[l - 2] == '\r') && (str[l - 1] == '\n')) {
|
||||
str[l - 2] = '\0';
|
||||
} else {
|
||||
str[l - 1] = '\0';
|
||||
}
|
||||
}
|
||||
if (blankline) {
|
||||
/* done - str is now the string to check */
|
||||
blankline = 0;
|
||||
*strarg = str;
|
||||
break;
|
||||
/* else read the patterns */
|
||||
} else if (add_pattern(patterns, patterns_count, (str[0] == ' ') ? &str[1] : str)) {
|
||||
goto error;
|
||||
}
|
||||
if (str[0] == ' ') {
|
||||
/* set invert-match */
|
||||
(*patterns)[*patterns_count - 1].invert = 1;
|
||||
}
|
||||
}
|
||||
if (!str || (blankline && (str[0] != '\0'))) {
|
||||
/* corner case, no input after blankline meaning the pattern to check is empty */
|
||||
if (create_empty_string(&str)) {
|
||||
goto error;
|
||||
}
|
||||
}
|
||||
*strarg = str;
|
||||
|
||||
return 0;
|
||||
|
||||
error:
|
||||
free(str);
|
||||
if (*infile) {
|
||||
fclose(*infile);
|
||||
*infile = NULL;
|
||||
}
|
||||
*strarg = NULL;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static char *
|
||||
modstr_init(void)
|
||||
{
|
||||
const char *module_start = "module yangre {"
|
||||
"yang-version 1.1;"
|
||||
"namespace urn:cesnet:libyang:yangre;"
|
||||
"prefix re;"
|
||||
"leaf pattern {"
|
||||
" type string {";
|
||||
|
||||
return strdup(module_start);
|
||||
}
|
||||
|
||||
static char *
|
||||
modstr_add_pattern(char **modstr, const struct yr_pattern *pattern)
|
||||
{
|
||||
char *new;
|
||||
const char *module_invertmatch = " { modifier invert-match; }";
|
||||
const char *module_match = ";";
|
||||
|
||||
if (asprintf(&new, "%s pattern %s%s", *modstr, pattern->expr,
|
||||
pattern->invert ? module_invertmatch : module_match) == -1) {
|
||||
fprintf(stderr, "yangre error: memory allocation failed.\n");
|
||||
return NULL;
|
||||
}
|
||||
free(*modstr);
|
||||
*modstr = NULL;
|
||||
|
||||
return new;
|
||||
}
|
||||
|
||||
static char *
|
||||
modstr_add_ending(char **modstr)
|
||||
{
|
||||
char *new;
|
||||
static const char *module_end = "}}}";
|
||||
|
||||
if (asprintf(&new, "%s%s", *modstr, module_end) == -1) {
|
||||
fprintf(stderr, "yangre error: memory allocation failed.\n");
|
||||
return NULL;
|
||||
}
|
||||
free(*modstr);
|
||||
*modstr = NULL;
|
||||
|
||||
return new;
|
||||
}
|
||||
|
||||
static int
|
||||
create_module(struct yr_pattern *patterns, int patterns_count, char **mod)
|
||||
{
|
||||
int i;
|
||||
char *new = NULL, *modstr;
|
||||
|
||||
if (!(modstr = modstr_init())) {
|
||||
goto error;
|
||||
}
|
||||
|
||||
for (i = 0; i < patterns_count; i++) {
|
||||
if (!(new = modstr_add_pattern(&modstr, &patterns[i]))) {
|
||||
goto error;
|
||||
}
|
||||
modstr = new;
|
||||
}
|
||||
|
||||
if (!(new = modstr_add_ending(&modstr))) {
|
||||
goto error;
|
||||
}
|
||||
|
||||
*mod = new;
|
||||
|
||||
return 0;
|
||||
|
||||
error:
|
||||
*mod = NULL;
|
||||
free(new);
|
||||
free(modstr);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static void
|
||||
print_verbose(struct yr_pattern *patterns, int patterns_count, char *str, LY_ERR match)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < patterns_count; i++) {
|
||||
fprintf(stdout, "pattern %d: %s\n", i + 1, patterns[i].expr);
|
||||
fprintf(stdout, "matching %d: %s\n", i + 1, patterns[i].invert ? "inverted" : "regular");
|
||||
}
|
||||
fprintf(stdout, "string : %s\n", str);
|
||||
if (match == LY_SUCCESS) {
|
||||
fprintf(stdout, "result : matching\n");
|
||||
} else if (match == LY_EVALID) {
|
||||
fprintf(stdout, "result : not matching\n");
|
||||
} else {
|
||||
fprintf(stdout, "result : error (%s)\n", ly_last_logmsg());
|
||||
}
|
||||
}
|
||||
|
||||
int
|
||||
main(int argc, char *argv[])
|
||||
{
|
||||
LY_ERR match;
|
||||
int i, opt_index = 0, ret = 1, verbose = 0;
|
||||
struct option options[] = {
|
||||
{"help", no_argument, NULL, 'h'},
|
||||
{"file", required_argument, NULL, 'f'},
|
||||
{"invert-match", no_argument, NULL, 'i'},
|
||||
{"pattern", required_argument, NULL, 'p'},
|
||||
{"version", no_argument, NULL, 'v'},
|
||||
{"verbose", no_argument, NULL, 'V'},
|
||||
{NULL, 0, NULL, 0}
|
||||
};
|
||||
struct yr_pattern *patterns = NULL;
|
||||
char *str = NULL, *modstr = NULL;
|
||||
int patterns_count = 0;
|
||||
struct ly_ctx *ctx = NULL;
|
||||
struct lys_module *mod;
|
||||
FILE *infile = NULL;
|
||||
ly_bool info_printed = 0;
|
||||
|
||||
opterr = 0;
|
||||
while ((i = getopt_long(argc, argv, "hf:ivVp:", options, &opt_index)) != -1) {
|
||||
switch (i) {
|
||||
case 'h':
|
||||
help();
|
||||
info_printed = 1;
|
||||
break;
|
||||
case 'f':
|
||||
if (infile) {
|
||||
help();
|
||||
fprintf(stderr, "yangre error: multiple input files are not supported.\n");
|
||||
goto cleanup;
|
||||
} else if (patterns_count) {
|
||||
help();
|
||||
fprintf(stderr, "yangre error: command line patterns cannot be mixed with file input.\n");
|
||||
goto cleanup;
|
||||
}
|
||||
if (parse_patterns_file(optarg, &infile, &patterns, &patterns_count, &str)) {
|
||||
goto cleanup;
|
||||
}
|
||||
break;
|
||||
case 'i':
|
||||
if (!patterns_count || patterns[patterns_count - 1].invert) {
|
||||
help();
|
||||
fprintf(stderr, "yangre error: invert-match option must follow some pattern.\n");
|
||||
goto cleanup;
|
||||
}
|
||||
patterns[patterns_count - 1].invert = 1;
|
||||
break;
|
||||
case 'p':
|
||||
if (infile) {
|
||||
help();
|
||||
fprintf(stderr, "yangre error: command line patterns cannot be mixed with file input.\n");
|
||||
goto cleanup;
|
||||
}
|
||||
if (add_pattern(&patterns, &patterns_count, optarg)) {
|
||||
goto cleanup;
|
||||
}
|
||||
break;
|
||||
case 'v':
|
||||
version();
|
||||
info_printed = 1;
|
||||
break;
|
||||
case 'V':
|
||||
verbose = 1;
|
||||
break;
|
||||
default:
|
||||
help();
|
||||
if (optopt) {
|
||||
fprintf(stderr, "yangre error: invalid option: -%c\n", optopt);
|
||||
} else {
|
||||
fprintf(stderr, "yangre error: invalid option: %s\n", argv[optind - 1]);
|
||||
}
|
||||
goto cleanup;
|
||||
}
|
||||
}
|
||||
|
||||
if (info_printed) {
|
||||
ret = 0;
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
if (!str) {
|
||||
/* check options compatibility */
|
||||
if (optind >= argc) {
|
||||
help();
|
||||
fprintf(stderr, "yangre error: missing <string> parameter to process.\n");
|
||||
goto cleanup;
|
||||
} else if (!patterns_count) {
|
||||
help();
|
||||
fprintf(stderr, "yangre error: missing pattern parameter to use.\n");
|
||||
goto cleanup;
|
||||
}
|
||||
str = argv[optind];
|
||||
}
|
||||
|
||||
if (create_module(patterns, patterns_count, &modstr)) {
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
if (ly_ctx_new(NULL, 0, &ctx)) {
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
ly_set_log_clb(pattern_error);
|
||||
if (lys_parse_mem(ctx, modstr, LYS_IN_YANG, &mod) || !mod->compiled || !mod->compiled->data) {
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
/* check the value */
|
||||
match = lyd_value_validate(ctx, mod->compiled->data, str, strlen(str), NULL, NULL, NULL);
|
||||
|
||||
if (verbose) {
|
||||
print_verbose(patterns, patterns_count, str, match);
|
||||
}
|
||||
if (match == LY_SUCCESS) {
|
||||
ret = 0;
|
||||
} else if (match == LY_EVALID) {
|
||||
ret = 2;
|
||||
} else {
|
||||
ret = 1;
|
||||
}
|
||||
|
||||
cleanup:
|
||||
ly_ctx_destroy(ctx);
|
||||
for (i = 0; i < patterns_count; i++) {
|
||||
free(patterns[i].expr);
|
||||
}
|
||||
if (patterns_count) {
|
||||
free(patterns);
|
||||
}
|
||||
free(modstr);
|
||||
if (infile) {
|
||||
fclose(infile);
|
||||
free(str);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue