main.c

/*
 * main.c -
 * unixtime that returns current time in epoch format.
 *
 * Copyright (C) 2020 iopsys Software Solutions AB. All rights reserved.
 *
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 */

#define _GNU_SOURCE

#include "getopt.h"
#include "helper.h"
#include "ubus_api_validator.h"
#include "ubus_call.h"
#include <dirent.h>
#include <json-validator.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#define API_PATH "/usr/share/api/"

struct global_args_t {
  char *path;
  const char *dir_path;
} global_args;

static const char *opt_string = "f:d:t:h";

static void show_usage(char *application_name) {

  fprintf(stdout,
          "\nUsage: %s: <options> \n"
          "Options: \n"
          "  -t Timeout for ubus call in seconds\n"
          "  -f json file with ubus objects\n"
          "  -d directory with json files \n"
          "  -h help\n\n",
          application_name);
}

static void parse_command_line_args(int argc, char *argv[]) {
  int opt;

  while ((opt = getopt(argc, argv, opt_string)) != -1) {

    switch (opt) {
    case 'f':
      global_args.path = optarg;
      break;

    case 'd':
      global_args.dir_path = optarg;
      break;

    case 't':
      set_ubus_timeout(atoi(optarg));
      break;

    case 'h':
      show_usage(argv[0]);
      exit(EXIT_SUCCESS);

    default:
      show_usage(argv[0]);
      exit(EXIT_FAILURE);
      break;
    }
  }
}

int main(int argc, char *argv[]) {

  int rv;

  parse_command_line_args(argc, argv);

  rv = schema_validator_init();
  if (rv) {
    perror("schema_validator_init failed");
    return EXIT_FAILURE;
  }

  rv = ubus_init();
  if (rv) {
    perror("ubus registration succesfull");
    return EXIT_FAILURE;
  }

  if (global_args.path != NULL)
    validate_path(global_args.path);

  if (global_args.path == NULL && global_args.dir_path != NULL) {
    DIR *d;
    // printf("\n working with directory: %s \n ", global_args.dir_path);

    d = opendir(global_args.dir_path);

    if (d) {
      struct dirent *dir;

      while ((dir = readdir(d)) != NULL) {
        char *res;
        char *format;

        if (strlastchar(global_args.dir_path, '/') == 0)
          format = "%s%s";
        else
          format = "%s/%s";
        rv = asprintf(&res, format, global_args.dir_path, dir->d_name);
        if (rv == -1) {
          fprintf(stderr, "asprintf() failed: insufficient memory!\n");
          return EXIT_FAILURE;
        }
        if (dir->d_type == DT_REG) {
          // printf("Result: '%s'\n", res);
          validate_path(res);
        }
        free(res);
      }
      closedir(d);
    } else {
      perror("directory error \n");
      return EXIT_FAILURE;
    }
  } else if (global_args.path == NULL && global_args.dir_path == NULL) {
    printf("trying default file... \n");
    validate_path("./json/ubus.json");
  }

  return 0;
}